diff --git a/src/darwin/Framework/CHIP/MTRBaseDevice.mm b/src/darwin/Framework/CHIP/MTRBaseDevice.mm
index 25e8908d22b4ae..71e1cde79e86f8 100644
--- a/src/darwin/Framework/CHIP/MTRBaseDevice.mm
+++ b/src/darwin/Framework/CHIP/MTRBaseDevice.mm
@@ -648,7 +648,6 @@ static CHIP_ERROR MTREncodeTLVFromDataValueDictionary(id object, chip::TLV::TLVW
 
 // Callback type to pass data value as an NSObject
 typedef void (*MTRDataValueDictionaryCallback)(void * context, id value);
-typedef void (*MTRErrorCallback)(void * context, CHIP_ERROR error);
 
 // Rename to be generic for decode and encode
 class MTRDataValueDictionaryDecodableType {
@@ -689,9 +688,9 @@ CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
 // Callback bridge for MTRDataValueDictionaryCallback
 class MTRDataValueDictionaryCallbackBridge : public MTRCallbackBridge<MTRDataValueDictionaryCallback> {
 public:
-    MTRDataValueDictionaryCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, MTRDeviceResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false)
-        : MTRCallbackBridge<MTRDataValueDictionaryCallback>(queue, device, handler, action, OnSuccessFn, keepAlive) {};
+    MTRDataValueDictionaryCallbackBridge(
+        dispatch_queue_t queue, MTRDeviceResponseHandler handler, MTRActionBlock action, bool keepAlive = false)
+        : MTRCallbackBridge<MTRDataValueDictionaryCallback>(queue, handler, action, OnSuccessFn, keepAlive) {};
 
     static void OnSuccessFn(void * context, id value) { DispatchSuccess(context, value); }
 };
@@ -791,14 +790,9 @@ - (void)readAttributesWithEndpointID:(NSNumber * _Nullable)endpointID
     clusterID = (clusterID == nil) ? nil : [clusterID copy];
     attributeID = (attributeID == nil) ? nil : [attributeID copy];
     params = (params == nil) ? nil : [params copy];
-    new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, chip::Callback::Cancelable * success,
-            chip::Callback::Cancelable * failure) {
-            auto successFn = chip::Callback::Callback<MTRDataValueDictionaryCallback>::FromCancelable(success);
-            auto failureFn = chip::Callback::Callback<MTRErrorCallback>::FromCancelable(failure);
-            auto context = successFn->mContext;
-            auto successCb = successFn->mCall;
-            auto failureCb = failureFn->mCall;
+    auto * bridge = new MTRDataValueDictionaryCallbackBridge(queue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MTRDataValueDictionaryCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             auto resultArray = [[NSMutableArray alloc] init];
             auto resultSuccess = [[NSMutableArray alloc] init];
             auto resultFailure = [[NSMutableArray alloc] init];
@@ -842,23 +836,23 @@ new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
             readParams.mAttributePathParamsListSize = 1;
             readParams.mIsFabricFiltered = params.filterByFabric;
 
-            auto onDone = [resultArray, resultSuccess, resultFailure, context, successCb, failureCb](
+            auto onDone = [resultArray, resultSuccess, resultFailure, bridge, successCb, failureCb](
                               BufferedReadAttributeCallback<MTRDataValueDictionaryDecodableType> * callback) {
                 if ([resultFailure count] > 0 || [resultSuccess count] == 0) {
                     // Failure
                     if (failureCb) {
                         if ([resultFailure count] > 0) {
-                            failureCb(context, [MTRError errorToCHIPErrorCode:resultFailure[0]]);
+                            failureCb(bridge, [MTRError errorToCHIPErrorCode:resultFailure[0]]);
                         } else if ([resultArray count] > 0) {
-                            failureCb(context, [MTRError errorToCHIPErrorCode:resultArray[0][MTRErrorKey]]);
+                            failureCb(bridge, [MTRError errorToCHIPErrorCode:resultArray[0][MTRErrorKey]]);
                         } else {
-                            failureCb(context, CHIP_ERROR_READ_FAILED);
+                            failureCb(bridge, CHIP_ERROR_READ_FAILED);
                         }
                     }
                 } else {
                     // Success
                     if (successCb) {
-                        successCb(context, resultArray);
+                        successCb(bridge, resultArray);
                     }
                 }
                 chip::Platform::Delete(callback);
@@ -887,6 +881,7 @@ new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
             callback.release();
             return err;
         });
+    std::move(*bridge).DispatchAction(self);
 }
 
 - (void)writeAttributeWithEndpointID:(NSNumber *)endpointID
@@ -897,14 +892,9 @@ - (void)writeAttributeWithEndpointID:(NSNumber *)endpointID
                                queue:(dispatch_queue_t)queue
                           completion:(MTRDeviceResponseHandler)completion
 {
-    new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, chip::Callback::Cancelable * success,
-            chip::Callback::Cancelable * failure) {
-            auto successFn = chip::Callback::Callback<MTRDataValueDictionaryCallback>::FromCancelable(success);
-            auto failureFn = chip::Callback::Callback<MTRErrorCallback>::FromCancelable(failure);
-            auto context = successFn->mContext;
-            auto successCb = successFn->mCall;
-            auto failureCb = failureFn->mCall;
+    auto * bridge = new MTRDataValueDictionaryCallbackBridge(queue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MTRDataValueDictionaryCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             auto resultArray = [[NSMutableArray alloc] init];
             auto resultSuccess = [[NSMutableArray alloc] init];
             auto resultFailure = [[NSMutableArray alloc] init];
@@ -929,22 +919,22 @@ new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
             };
 
             auto onDoneCb
-                = [context, successCb, failureCb, resultArray, resultSuccess, resultFailure](app::WriteClient * pWriteClient) {
+                = [bridge, successCb, failureCb, resultArray, resultSuccess, resultFailure](app::WriteClient * pWriteClient) {
                       if ([resultFailure count] > 0 || [resultSuccess count] == 0) {
                           // Failure
                           if (failureCb) {
                               if ([resultFailure count] > 0) {
-                                  failureCb(context, [MTRError errorToCHIPErrorCode:resultFailure[0]]);
+                                  failureCb(bridge, [MTRError errorToCHIPErrorCode:resultFailure[0]]);
                               } else if ([resultArray count] > 0) {
-                                  failureCb(context, [MTRError errorToCHIPErrorCode:resultArray[0][MTRErrorKey]]);
+                                  failureCb(bridge, [MTRError errorToCHIPErrorCode:resultArray[0][MTRErrorKey]]);
                               } else {
-                                  failureCb(context, CHIP_ERROR_WRITE_FAILED);
+                                  failureCb(bridge, CHIP_ERROR_WRITE_FAILED);
                               }
                           }
                       } else {
                           // Success
                           if (successCb) {
-                              successCb(context, resultArray);
+                              successCb(bridge, resultArray);
                           }
                       }
                   };
@@ -956,6 +946,7 @@ new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
                 onSuccessCb, onFailureCb, (timeoutMs == nil) ? NullOptional : Optional<uint16_t>([timeoutMs unsignedShortValue]),
                 onDoneCb, NullOptional);
         });
+    std::move(*bridge).DispatchAction(self);
 }
 
 class NSObjectCommandCallback final : public app::CommandSender::Callback {
@@ -1045,14 +1036,9 @@ - (void)invokeCommandWithEndpointID:(NSNumber *)endpointID
     commandFields = (commandFields == nil) ? nil : [commandFields copy];
     timeoutMs = (timeoutMs == nil) ? nil : [timeoutMs copy];
 
-    new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, chip::Callback::Cancelable * success,
-            chip::Callback::Cancelable * failure) {
-            auto successFn = chip::Callback::Callback<MTRDataValueDictionaryCallback>::FromCancelable(success);
-            auto failureFn = chip::Callback::Callback<MTRErrorCallback>::FromCancelable(failure);
-            auto context = successFn->mContext;
-            auto successCb = successFn->mCall;
-            auto failureCb = failureFn->mCall;
+    auto * bridge = new MTRDataValueDictionaryCallbackBridge(queue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MTRDataValueDictionaryCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             auto resultArray = [[NSMutableArray alloc] init];
             auto resultSuccess = [[NSMutableArray alloc] init];
             auto resultFailure = [[NSMutableArray alloc] init];
@@ -1086,21 +1072,21 @@ new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
             VerifyOrReturnError(decoder != nullptr, CHIP_ERROR_NO_MEMORY);
 
             auto rawDecoderPtr = decoder.get();
-            auto onDoneCb = [rawDecoderPtr, context, successCb, failureCb, resultArray, resultSuccess, resultFailure](
+            auto onDoneCb = [rawDecoderPtr, bridge, successCb, failureCb, resultArray, resultSuccess, resultFailure](
                                 app::CommandSender * commandSender) {
                 if ([resultFailure count] > 0 || [resultSuccess count] == 0) {
                     // Failure
                     if (failureCb) {
                         if ([resultFailure count] > 0) {
-                            failureCb(context, [MTRError errorToCHIPErrorCode:resultFailure[0]]);
+                            failureCb(bridge, [MTRError errorToCHIPErrorCode:resultFailure[0]]);
                         } else {
-                            failureCb(context, CHIP_ERROR_WRITE_FAILED);
+                            failureCb(bridge, CHIP_ERROR_WRITE_FAILED);
                         }
                     }
                 } else {
                     // Success
                     if (successCb) {
-                        successCb(context, resultArray);
+                        successCb(bridge, resultArray);
                     }
                 }
                 chip::Platform::Delete(commandSender);
@@ -1121,6 +1107,7 @@ new MTRDataValueDictionaryCallbackBridge(queue, self, completion,
             commandSender.release();
             return CHIP_NO_ERROR;
         });
+    std::move(*bridge).DispatchAction(self);
 }
 
 - (void)subscribeToAttributesWithEndpointID:(NSNumber * _Nullable)endpointID
diff --git a/src/darwin/Framework/CHIP/MTRCallbackBridgeBase_internal.h b/src/darwin/Framework/CHIP/MTRCallbackBridgeBase_internal.h
index 3ea7d4c0fb8260..56442b07480daa 100644
--- a/src/darwin/Framework/CHIP/MTRCallbackBridgeBase_internal.h
+++ b/src/darwin/Framework/CHIP/MTRCallbackBridgeBase_internal.h
@@ -32,90 +32,122 @@
  * communication with the device in question has been established, as far as we
  * know.
  */
+class MTRCallbackBridgeBase {
+};
 
 // TODO: ADD NS_ASSUME_NONNULL_BEGIN to this header.  When that happens, note
 // that in MTRActionBlock the two callback pointers are nonnull and the two
-// arguments of ResponseHandler are both nullable.
+// arguments of MTRResponseHandler are both nullable.
 
-typedef void (^ResponseHandler)(id value, NSError * error);
-typedef CHIP_ERROR (^MTRActionBlock)(chip::Messaging::ExchangeManager & exchangeManager, const chip::SessionHandle & session,
-    chip::Callback::Cancelable * success, chip::Callback::Cancelable * failure);
-typedef CHIP_ERROR (^MTRLocalActionBlock)(chip::Callback::Cancelable * success, chip::Callback::Cancelable * failure);
-typedef void (*DefaultFailureCallbackType)(void *, CHIP_ERROR);
+typedef void (^MTRResponseHandler)(id value, NSError * error);
+typedef void (*MTRErrorCallback)(void * context, CHIP_ERROR error);
 
-template <class T> class MTRCallbackBridge {
+/**
+ * The bridge will pass itself as the last argument to the action block.
+ *
+ * The action block must do one of three things:
+ *
+ * 1) Return an error.
+ * 2) Call the "successCb" callback, with the bridge passed to the block as the
+ *    context, possibly asynchronously.
+ * 3) Call the "failureCb" callback, with the bridge passed to the block as the
+ *    context, possibly asynchronously.
+ *
+ * For an MTRCallbackBridge that has keepAlive set to true, the success/failure
+ * callbacks may be called multiple times.  If keepAlive is false, there must be
+ * no calls after the first one.
+ */
+template <typename SuccessCallback>
+using MTRActionBlockT = CHIP_ERROR (^)(chip::Messaging::ExchangeManager & exchangeManager, const chip::SessionHandle & session,
+    SuccessCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge);
+template <typename SuccessCallback>
+using MTRLocalActionBlockT = CHIP_ERROR (^)(SuccessCallback successCb, MTRErrorCallback failureCb);
+
+template <class T> class MTRCallbackBridge : public MTRCallbackBridgeBase {
 public:
+    using MTRActionBlock = MTRActionBlockT<T>;
+    using MTRLocalActionBlock = MTRLocalActionBlockT<T>;
+
     /**
-     * Run the given MTRLocalActionBlock on the Matter thread, then handle
-     * converting the value produced by the success callback to the right type
-     * so it can be passed to a callback of the type we're templated over.
-     *
-     * Does not attempt to establish any sessions to devices.  Must not be used
-     * with any action blocks that need a session.
+     * Construct a callback bridge, which can then have DispatcLocalAction() called
+     * on it.
      */
-    MTRCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action, T OnSuccessFn, bool keepAlive)
+    MTRCallbackBridge(dispatch_queue_t queue, MTRResponseHandler handler, T OnSuccessFn, bool keepAlive)
         : mQueue(queue)
         , mHandler(handler)
         , mKeepAlive(keepAlive)
-        , mSuccess(OnSuccessFn, this)
-        , mFailure(OnFailureFn, this)
+        , mSuccess(OnSuccessFn)
+        , mFailure(OnFailureFn)
     {
-        LogRequestStart();
-
-        // For now keep sync dispatch here.
-        dispatch_sync(chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue(), ^{
-            CHIP_ERROR err = action(mSuccess.Cancel(), mFailure.Cancel());
-            if (err != CHIP_NO_ERROR) {
-                NSLog(@"Failure performing action. C++-mangled success callback type: '%s', error: %s", typeid(T).name(),
-                    chip::ErrorStr(err));
-
-                // Take the normal async error-reporting codepath.  This will also
-                // handle cleaning us up properly.
-                OnFailureFn(this, err);
-            }
-        });
     }
 
     /**
-     * Run the given MTRActionBlock on the Matter thread, after getting a CASE
-     * session (possibly pre-existing) to the given node ID on the fabric
-     * represented by the given MTRDeviceController.  On success, convert the
-     * success value to whatever type it needs to be to call the callback type
-     * we're templated over.
+     * Construct a callback bridge, which can then have DispatchAction() called
+     * on it.
      */
-    MTRCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, T OnSuccessFn, bool keepAlive)
+    MTRCallbackBridge(dispatch_queue_t queue, MTRResponseHandler handler, MTRActionBlock action, T OnSuccessFn, bool keepAlive)
         : mQueue(queue)
         , mHandler(handler)
         , mAction(action)
         , mKeepAlive(keepAlive)
-        , mSuccess(OnSuccessFn, this)
-        , mFailure(OnFailureFn, this)
+        , mSuccess(OnSuccessFn)
+        , mFailure(OnFailureFn)
     {
-        ActionWithNodeID(nodeID, controller);
     }
 
+    /**
+     * Run the given MTRActionBlock on the Matter thread, after getting a CASE
+     * session (possibly pre-existing) to the given node ID on the fabric
+     * represented by the given MTRDeviceController.  On success, convert the
+     * success value to whatever type it needs to be to call the callback type
+     * we're templated over.  Once this function has been called, on a callback
+     * bridge allocated with `new`, the bridge object must not be accessed by
+     * the caller.  The action block will handle deleting the bridge.
+     */
+    void DispatchAction(chip::NodeId nodeID, MTRDeviceController * controller) && { ActionWithNodeID(nodeID, controller); }
+
     /**
      * Run the given MTRActionBlock on the Matter thread after getting a secure
      * session corresponding to the given MTRBaseDevice.  On success, convert
      * the success value to whatever type it needs to be to call the callback
-     * type we're templated over.
+     * type we're templated over.  Once this function has been called, on a callback
+     * bridge allocated with `new`, the bridge object must not be accessed by
+     * the caller.  The action block will handle deleting the bridge.
      */
-    MTRCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, T OnSuccessFn,
-        bool keepAlive)
-        : mQueue(queue)
-        , mHandler(handler)
-        , mAction(action)
-        , mKeepAlive(keepAlive)
-        , mSuccess(OnSuccessFn, this)
-        , mFailure(OnFailureFn, this)
+    void DispatchAction(MTRBaseDevice * device) &&
     {
         if (device.isPASEDevice) {
             ActionWithPASEDevice(device);
         } else {
             ActionWithNodeID(device.nodeID, device.deviceController);
         }
-    };
+    }
+
+    /**
+     * Run the given MTRLocalActionBlock on the Matter thread, then handle
+     * converting the value produced by the success callback to the right type
+     * so it can be passed to a callback of the type we're templated over.
+     *
+     * Does not attempt to establish any sessions to devices.  Must not be used
+     * with any action blocks that need a session.
+     */
+    void DispatchLocalAction(MTRLocalActionBlock action)
+    {
+        LogRequestStart();
+
+        // For now keep sync dispatch here.
+        dispatch_sync(chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue(), ^{
+            CHIP_ERROR err = action(mSuccess, mFailure);
+            if (err != CHIP_NO_ERROR) {
+                NSLog(@"Failure performing action. C++-mangled success callback type: '%s', error: %s", typeid(T).name(),
+                    chip::ErrorStr(err));
+
+                // Take the normal async error-reporting codepath.  This will also
+                // handle cleaning us up properly.
+                OnFailureFn(this, err);
+            }
+        });
+    }
 
     void ActionWithPASEDevice(MTRBaseDevice * device)
     {
@@ -167,7 +199,7 @@ template <class T> class MTRCallbackBridge {
             return;
         }
 
-        CHIP_ERROR err = action(*exchangeManager, session.Value(), mSuccess.Cancel(), mFailure.Cancel());
+        CHIP_ERROR err = action(*exchangeManager, session.Value(), mSuccess, mFailure, this);
         if (err != CHIP_NO_ERROR) {
             NSLog(@"Failure performing action. C++-mangled success callback type: '%s', error: %s", typeid(T).name(),
                 chip::ErrorStr(err));
@@ -218,12 +250,12 @@ template <class T> class MTRCallbackBridge {
         });
     }
 
-    ResponseHandler mHandler;
+    MTRResponseHandler mHandler;
     MTRActionBlock mAction;
     bool mKeepAlive;
 
-    chip::Callback::Callback<T> mSuccess;
-    chip::Callback::Callback<DefaultFailureCallbackType> mFailure;
+    T mSuccess;
+    MTRErrorCallback mFailure;
 
     // Measure the time it took for the callback to trigger
     NSDate * mRequestTime;
diff --git a/src/darwin/Framework/CHIP/templates/MTRBaseClusters-src.zapt b/src/darwin/Framework/CHIP/templates/MTRBaseClusters-src.zapt
index d3fc38390fe95a..bde911c9d391f1 100644
--- a/src/darwin/Framework/CHIP/templates/MTRBaseClusters-src.zapt
+++ b/src/darwin/Framework/CHIP/templates/MTRBaseClusters-src.zapt
@@ -53,8 +53,7 @@ using chip::SessionHandle;
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
-      self.device,
+    auto * bridge = new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
       {{#if hasSpecificResponse}}
         {{! This treats completion as taking an id for the data.  This is
             not great from a type-safety perspective, of course. }}
@@ -67,7 +66,7 @@ using chip::SessionHandle;
           completion(error);
         },
       {{/if}}
-      ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+      ^(ExchangeManager & exchangeManager, const SessionHandle & session, {{>callbackName}}CallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
         chip::Optional<uint16_t> timedInvokeTimeoutMs;
         ListFreer listFreer;
         {{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Type request;
@@ -95,11 +94,10 @@ using chip::SessionHandle;
           {{/last}}
         {{/chip_cluster_command_arguments}}
 
-        auto successFn = Callback<{{>callbackName}}CallbackType>::FromCancelable(success);
-        auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
         chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
-        return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+        return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
     });
+    std::move(*bridge).DispatchAction(self.device);
 }
 {{/chip_cluster_commands}}
 
@@ -117,22 +115,20 @@ using chip::SessionHandle;
     // Make a copy of params before we go async.
     params = [params copy];
     {{/if_is_fabric_scoped_struct~}}
-    new MTR{{>attribute_data_callback_name}}CallbackBridge(self.callbackQueue,
-      self.device,
+    auto * bridge = new MTR{{>attribute_data_callback_name}}CallbackBridge(self.callbackQueue,
       {{! This treats completion as taking an id for the data.  This is
           not great from a type-safety perspective, of course. }}
       completion,
-      ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+      ^(ExchangeManager & exchangeManager, const SessionHandle & session, {{>attribute_data_callback_name}}Callback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
           using TypeInfo = {{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo;
-          auto successFn = Callback<{{>attribute_data_callback_name}}Callback>::FromCancelable(success);
-          auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
           chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
-          return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall
+          return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb
           {{~#if_is_fabric_scoped_struct type~}}
           , params.filterByFabric
           {{~/if_is_fabric_scoped_struct~}}
           );
       });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 {{#if isWritableAttribute}}
@@ -147,15 +143,14 @@ using chip::SessionHandle;
     params = [params copy];
     value = [value copy];
 
-    new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
-      self.device,
+    auto * bridge = new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
       {{! For now, don't change the bridge API; instead just use an adapter
           to invoke our completion handler. This is not great from a
           type-safety perspective, of course. }}
       ^(id _Nullable ignored, NSError * _Nullable error) {
         completion(error);
       },
-      ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+      ^(ExchangeManager & exchangeManager, const SessionHandle & session, {{>callbackName}}CallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
         chip::Optional<uint16_t> timedWriteTimeout;
         if (params != nil) {
           if (params.timedWriteTimeout != nil){
@@ -172,13 +167,11 @@ using chip::SessionHandle;
         using TypeInfo = {{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo;
         TypeInfo::Type cppValue;
         {{>encode_value target="cppValue" source="value" cluster=parent.name errorCode="return CHIP_ERROR_INVALID_ARGUMENT;" depth=0}}
-        auto successFn = Callback<{{>callbackName}}CallbackType>::FromCancelable(success);
-        auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
         chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
-        return cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
     });
-
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 {{/if}}
@@ -189,36 +182,33 @@ reportHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge * callbackBridge = new MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge(self.callbackQueue,
-      self.device,
+    auto * bridge = new MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge(self.callbackQueue,
       {{! This treats reportHandler as taking an id for the data.  This is
           not great from a type-safety perspective, of course. }}
       reportHandler,
-      ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+      ^(ExchangeManager & exchangeManager, const SessionHandle & session,  {{>attribute_data_callback_name}}Callback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+          auto * typedBridge = static_cast<MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge *>(bridge);
           if (!params.resubscribeIfLost) {
               // We don't support disabling auto-resubscribe.
               return CHIP_ERROR_INVALID_ARGUMENT;
           }
           using TypeInfo = {{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo;
-          auto successFn = Callback<{{>attribute_data_callback_name}}Callback>::FromCancelable(success);
-          auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
           chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
-          MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-          return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall, [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue], MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+          return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue], MTR{{>attribute_data_callback_name}}CallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
               params.filterByFabric,
               !params.replaceExistingSubscriptions,
               chip::NullOptional,
-              [innerCallbackBridge](void) { delete innerCallbackBridge; }
+              [typedBridge](void) { delete typedBridge; }
           );
       }, subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void) read{{>attribute}}WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint  queue:(dispatch_queue_t)queue completion:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTR{{>attribute_data_callback_name}}CallbackBridge(queue,
-      completion,
-      ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTR{{>attribute_data_callback_name}}CallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^({{>attribute_data_callback_name}}Callback successCb, MTRErrorCallback failureCb) {
           if (attributeCacheContainer.cppAttributeCache) {
               chip::app::ConcreteAttributePath path;
               using TypeInfo = {{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::TypeInfo;
@@ -227,10 +217,9 @@ reportHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value
               path.mAttributeId = TypeInfo::GetAttributeId();
               TypeInfo::DecodableType value;
               CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-              auto successFn = Callback<{{>attribute_data_callback_name}}Callback>::FromCancelable(success);
               if (err == CHIP_NO_ERROR)
               {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
               }
               return err;
           }
diff --git a/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt b/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt
index 76acf303d10c3e..59e5575e462a10 100644
--- a/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt
+++ b/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt
@@ -62,8 +62,7 @@ using chip::SessionHandle;
     MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice *baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-        new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
-          baseDevice,
+        auto * bridge = new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
           {{#if hasSpecificResponse}}
             {{! This treats completion as taking an id for the data.  This is
                 not great from a type-safety perspective, of course. }}
@@ -77,7 +76,7 @@ using chip::SessionHandle;
                   [workItem endWork];
             },
           {{/if}}
-          ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+          ^(ExchangeManager & exchangeManager, const SessionHandle & session, {{>callbackName}}CallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             {{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Type request;
@@ -103,11 +102,10 @@ using chip::SessionHandle;
               {{/last}}
             {{/chip_cluster_command_arguments}}
 
-            auto successFn = Callback<{{>callbackName}}CallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-      });
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
+        });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
diff --git a/src/darwin/Framework/CHIP/templates/partials/MTRCallbackBridge.zapt b/src/darwin/Framework/CHIP/templates/partials/MTRCallbackBridge.zapt
index 40656f44ce3a0c..1f6b97e9a2b24e 100644
--- a/src/darwin/Framework/CHIP/templates/partials/MTRCallbackBridge.zapt
+++ b/src/darwin/Framework/CHIP/templates/partials/MTRCallbackBridge.zapt
@@ -13,16 +13,12 @@
 class MTR{{> @partial-block}}Bridge : public MTRCallbackBridge<{{>callbackType}}>
 {
 public:
-    MTR{{> @partial-block}}Bridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action, bool keepAlive = false)
-      : MTRCallbackBridge<{{>callbackType}}>(queue, handler, action, OnSuccessFn, keepAlive)
-      {};
-
-    MTR{{> @partial-block}}Bridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false)
-      : MTRCallbackBridge<{{>callbackType}}>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive)
+    MTR{{> @partial-block}}Bridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false)
+      : MTRCallbackBridge<{{>callbackType}}>(queue, handler, OnSuccessFn, keepAlive)
       {};
 
-    MTR{{> @partial-block}}Bridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false)
-      : MTRCallbackBridge<{{>callbackType}}>(queue, device, handler, action, OnSuccessFn, keepAlive)
+    MTR{{> @partial-block}}Bridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false)
+      : MTRCallbackBridge<{{>callbackType}}>(queue, handler, action, OnSuccessFn, keepAlive)
       {};
 
     static void OnSuccessFn(void * context
@@ -46,13 +42,8 @@ public:
 class MTR{{> @partial-block}}SubscriptionBridge : public MTR{{> @partial-block}}Bridge
 {
 public:
-    MTR{{> @partial-block}}SubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler, MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler)
-      : MTR{{> @partial-block}}Bridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-      {}
-
-    MTR{{> @partial-block}}SubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler)
-      : MTR{{> @partial-block}}Bridge(queue, device, handler, action, true),
+    MTR{{> @partial-block}}SubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler)
+      : MTR{{> @partial-block}}Bridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
       {}
 
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
index 2883c1bde75a46..3ebc20195b0e81 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
@@ -57,12 +57,13 @@ - (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Identify::Commands::Identify::Type request;
@@ -73,23 +74,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.identifyTime = params.identifyTime.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Identify::Commands::TriggerEffect::Type request;
@@ -103,23 +104,22 @@ new MTRCommandSuccessCallbackBridge(
             request.effectVariant
                 = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeIdentifyTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -134,12 +134,13 @@ - (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -151,13 +152,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeIdentifyTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -166,26 +165,25 @@ - (void)subscribeAttributeIdentifyTimeWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeIdentifyTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -193,7 +191,8 @@ + (void)readAttributeIdentifyTimeWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
@@ -202,9 +201,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -214,14 +212,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeIdentifyTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeIdentifyTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -230,26 +228,25 @@ - (void)subscribeAttributeIdentifyTypeWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeIdentifyTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -257,7 +254,8 @@ + (void)readAttributeIdentifyTypeWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
@@ -266,9 +264,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -278,14 +275,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IdentifyGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<IdentifyGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -295,27 +293,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<IdentifyGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IdentifyGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -324,8 +322,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(IdentifyGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
@@ -334,9 +333,8 @@ new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<IdentifyGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -346,14 +344,15 @@ new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IdentifyAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<IdentifyAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -363,27 +362,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<IdentifyAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IdentifyAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -392,35 +391,36 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<IdentifyAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(IdentifyAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIdentifyAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIdentifyAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, IdentifyAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<IdentifyAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -429,27 +429,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<IdentifyAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, IdentifyAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -457,7 +456,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIdentifyAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIdentifyAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(IdentifyAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
@@ -466,9 +466,8 @@ new MTRIdentifyAttributeListListAttributeCallbackBridge(queue, completion, ^(Can
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<IdentifyAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -478,14 +477,14 @@ new MTRIdentifyAttributeListListAttributeCallbackBridge(queue, completion, ^(Can
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -494,26 +493,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -521,7 +519,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
@@ -530,9 +529,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -542,14 +540,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -558,26 +556,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -585,7 +582,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
@@ -594,9 +592,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -897,8 +894,9 @@ - (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterAddGroupResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Groups::Commands::AddGroup::Type request;
@@ -910,11 +908,10 @@ new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, self.devi
             request.groupId = params.groupId.unsignedShortValue;
             request.groupName = [self asCharSpan:params.groupName];
 
-            auto successFn = Callback<GroupsClusterAddGroupResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
@@ -923,8 +920,9 @@ - (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterViewGroupResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Groups::Commands::ViewGroup::Type request;
@@ -935,11 +933,10 @@ new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, self.dev
             }
             request.groupId = params.groupId.unsignedShortValue;
 
-            auto successFn = Callback<GroupsClusterViewGroupResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params
@@ -948,8 +945,10 @@ - (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupsClusterGetGroupMembershipResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Groups::Commands::GetGroupMembership::Type request;
@@ -981,11 +980,10 @@ new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue,
                 }
             }
 
-            auto successFn = Callback<GroupsClusterGetGroupMembershipResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
@@ -994,8 +992,9 @@ - (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterRemoveGroupResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Groups::Commands::RemoveGroup::Type request;
@@ -1006,11 +1005,10 @@ new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, self.d
             }
             request.groupId = params.groupId.unsignedShortValue;
 
-            auto successFn = Callback<GroupsClusterRemoveGroupResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)removeAllGroupsWithCompletion:(MTRStatusCompletion)completion
@@ -1022,12 +1020,13 @@ - (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Null
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Groups::Commands::RemoveAllGroups::Type request;
@@ -1037,11 +1036,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params
@@ -1049,12 +1047,13 @@ - (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Groups::Commands::AddGroupIfIdentifying::Type request;
@@ -1066,23 +1065,22 @@ new MTRCommandSuccessCallbackBridge(
             request.groupId = params.groupId.unsignedShortValue;
             request.groupName = [self asCharSpan:params.groupName];
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -1091,26 +1089,25 @@ - (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -1118,7 +1115,8 @@ + (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
@@ -1127,9 +1125,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -1139,14 +1136,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<GroupsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -1156,27 +1153,26 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<GroupsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -1185,35 +1181,36 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<GroupsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GroupsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<GroupsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -1223,27 +1220,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<GroupsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -1252,7 +1248,8 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(GroupsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
@@ -1261,9 +1258,8 @@ new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<GroupsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -1273,14 +1269,14 @@ new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<GroupsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -1289,27 +1285,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<GroupsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -1317,7 +1312,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(GroupsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
@@ -1326,9 +1322,8 @@ new MTRGroupsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cance
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<GroupsAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -1338,14 +1333,14 @@ new MTRGroupsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cance
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -1354,26 +1349,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -1381,7 +1375,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
@@ -1390,9 +1385,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -1402,14 +1396,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -1418,26 +1412,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -1445,7 +1438,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
@@ -1454,9 +1448,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -1742,8 +1735,9 @@ - (void)addSceneWithParams:(MTRScenesClusterAddSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterAddSceneResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::AddScene::Type request;
@@ -1830,11 +1824,10 @@ new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, self.devi
                 }
             }
 
-            auto successFn = Callback<ScenesClusterAddSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
@@ -1843,8 +1836,9 @@ - (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterViewSceneResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::ViewScene::Type request;
@@ -1856,11 +1850,10 @@ new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, self.dev
             request.groupId = params.groupId.unsignedShortValue;
             request.sceneId = params.sceneId.unsignedCharValue;
 
-            auto successFn = Callback<ScenesClusterViewSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
@@ -1869,8 +1862,9 @@ - (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterRemoveSceneResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::RemoveScene::Type request;
@@ -1882,11 +1876,10 @@ new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, self.d
             request.groupId = params.groupId.unsignedShortValue;
             request.sceneId = params.sceneId.unsignedCharValue;
 
-            auto successFn = Callback<ScenesClusterRemoveSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)params
@@ -1895,8 +1888,10 @@ - (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesClusterRemoveAllScenesResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::RemoveAllScenes::Type request;
@@ -1907,11 +1902,10 @@ new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, se
             }
             request.groupId = params.groupId.unsignedShortValue;
 
-            auto successFn = Callback<ScenesClusterRemoveAllScenesResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
@@ -1920,8 +1914,9 @@ - (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterStoreSceneResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::StoreScene::Type request;
@@ -1933,23 +1928,23 @@ new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, self.de
             request.groupId = params.groupId.unsignedShortValue;
             request.sceneId = params.sceneId.unsignedCharValue;
 
-            auto successFn = Callback<ScenesClusterStoreSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::RecallScene::Type request;
@@ -1970,11 +1965,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *)params
@@ -1983,8 +1977,10 @@ - (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesClusterGetSceneMembershipResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::GetSceneMembership::Type request;
@@ -1995,11 +1991,10 @@ new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue,
             }
             request.groupId = params.groupId.unsignedShortValue;
 
-            auto successFn = Callback<ScenesClusterGetSceneMembershipResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)params
@@ -2008,8 +2003,10 @@ - (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesClusterEnhancedAddSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::EnhancedAddScene::Type request;
@@ -2096,11 +2093,10 @@ new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, s
                 }
             }
 
-            auto successFn = Callback<ScenesClusterEnhancedAddSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)params
@@ -2109,8 +2105,10 @@ - (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesClusterEnhancedViewSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::EnhancedViewScene::Type request;
@@ -2122,11 +2120,10 @@ new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue,
             request.groupId = params.groupId.unsignedShortValue;
             request.sceneId = params.sceneId.unsignedCharValue;
 
-            auto successFn = Callback<ScenesClusterEnhancedViewSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
@@ -2135,8 +2132,9 @@ - (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterCopySceneResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Scenes::Commands::CopyScene::Type request;
@@ -2151,23 +2149,22 @@ new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, self.dev
             request.groupIdTo = params.groupIdTo.unsignedShortValue;
             request.sceneIdTo = params.sceneIdTo.unsignedCharValue;
 
-            auto successFn = Callback<ScenesClusterCopySceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeSceneCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSceneCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2176,26 +2173,25 @@ - (void)subscribeAttributeSceneCountWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSceneCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2203,7 +2199,8 @@ + (void)readAttributeSceneCountWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
@@ -2212,9 +2209,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2224,14 +2220,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCurrentSceneWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentSceneWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2240,26 +2236,25 @@ - (void)subscribeAttributeCurrentSceneWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentSceneWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2267,7 +2262,8 @@ + (void)readAttributeCurrentSceneWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
@@ -2276,9 +2272,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2288,14 +2283,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCurrentGroupWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentGroupWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2304,26 +2299,25 @@ - (void)subscribeAttributeCurrentGroupWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentGroupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2331,7 +2325,8 @@ + (void)readAttributeCurrentGroupWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
@@ -2340,9 +2335,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2352,14 +2346,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeSceneValidWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSceneValidWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2368,26 +2362,25 @@ - (void)subscribeAttributeSceneValidWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSceneValidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2395,7 +2388,8 @@ + (void)readAttributeSceneValidWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
@@ -2404,9 +2398,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2416,14 +2409,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2432,26 +2425,25 @@ - (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2459,7 +2451,8 @@ + (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
@@ -2468,9 +2461,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2480,14 +2472,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeLastConfiguredByWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLastConfiguredByWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2496,27 +2488,25 @@ - (void)subscribeAttributeLastConfiguredByWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
 
-                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLastConfiguredByWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2524,7 +2514,8 @@ + (void)readAttributeLastConfiguredByWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
@@ -2533,9 +2524,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2545,14 +2535,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRScenesGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ScenesGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2562,27 +2552,26 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ScenesGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2591,35 +2580,36 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ScenesGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ScenesGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRScenesAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ScenesAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2629,27 +2619,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ScenesAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ScenesAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2658,7 +2647,8 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ScenesAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
@@ -2667,9 +2657,8 @@ new MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ScenesAcceptedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2679,14 +2668,14 @@ new MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRScenesAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ScenesAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2695,27 +2684,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRScenesAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ScenesAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRScenesAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRScenesAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRScenesAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRScenesAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2723,7 +2711,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRScenesAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRScenesAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ScenesAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
@@ -2732,9 +2721,8 @@ new MTRScenesAttributeListListAttributeCallbackBridge(queue, completion, ^(Cance
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ScenesAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2744,14 +2732,14 @@ new MTRScenesAttributeListListAttributeCallbackBridge(queue, completion, ^(Cance
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2760,26 +2748,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2787,7 +2774,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
@@ -2796,9 +2784,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -2808,14 +2795,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -2824,26 +2811,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -2851,7 +2837,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
@@ -2860,9 +2847,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -3340,12 +3326,13 @@ - (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params completion:(M
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OnOff::Commands::Off::Type request;
@@ -3355,11 +3342,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)onWithCompletion:(MTRStatusCompletion)completion
@@ -3370,12 +3356,13 @@ - (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params completion:(MTR
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OnOff::Commands::On::Type request;
@@ -3385,11 +3372,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)toggleWithCompletion:(MTRStatusCompletion)completion
@@ -3400,12 +3386,13 @@ - (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params complet
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OnOff::Commands::Toggle::Type request;
@@ -3415,23 +3402,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OnOff::Commands::OffWithEffect::Type request;
@@ -3444,11 +3431,10 @@ new MTRCommandSuccessCallbackBridge(
             request.effectVariant
                 = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)onWithRecallGlobalSceneWithCompletion:(MTRStatusCompletion)completion
@@ -3460,12 +3446,13 @@ - (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalScen
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OnOff::Commands::OnWithRecallGlobalScene::Type request;
@@ -3475,23 +3462,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OnOff::Commands::OnWithTimedOff::Type request;
@@ -3505,23 +3492,22 @@ new MTRCommandSuccessCallbackBridge(
             request.onTime = params.onTime.unsignedShortValue;
             request.offWaitTime = params.offWaitTime.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOnOffWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -3530,26 +3516,25 @@ - (void)subscribeAttributeOnOffWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -3557,7 +3542,8 @@ + (void)readAttributeOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
@@ -3566,9 +3552,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -3578,14 +3563,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGlobalSceneControlWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGlobalSceneControlWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -3595,26 +3580,25 @@ - (void)subscribeAttributeGlobalSceneControlWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGlobalSceneControlWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -3623,7 +3607,8 @@ + (void)readAttributeGlobalSceneControlWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
@@ -3632,9 +3617,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -3644,14 +3628,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOnTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -3666,12 +3650,13 @@ - (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -3683,13 +3668,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOnTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -3698,26 +3681,25 @@ - (void)subscribeAttributeOnTimeWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOnTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -3725,7 +3707,8 @@ + (void)readAttributeOnTimeWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
@@ -3734,9 +3717,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -3746,14 +3728,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOffWaitTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -3768,12 +3750,13 @@ - (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -3785,13 +3768,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOffWaitTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -3800,26 +3781,25 @@ - (void)subscribeAttributeOffWaitTimeWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOffWaitTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -3827,7 +3807,8 @@ + (void)readAttributeOffWaitTimeWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
@@ -3836,9 +3817,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -3848,14 +3828,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeStartUpOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableOnOffClusterOnOffStartUpOnOffAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
-            auto successFn = Callback<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -3870,12 +3851,13 @@ - (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -3892,13 +3874,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStartUpOnOffWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -3907,27 +3887,27 @@ - (void)subscribeAttributeStartUpOnOffWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
-                auto successFn = Callback<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableOnOffClusterOnOffStartUpOnOffAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
 
-                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStartUpOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -3935,8 +3915,9 @@ + (void)readAttributeStartUpOnOffWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableOnOffClusterOnOffStartUpOnOffAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
@@ -3945,9 +3926,8 @@ new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -3957,14 +3937,14 @@ new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<OnOffGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -3974,27 +3954,26 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<OnOffGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4003,7 +3982,8 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(OnOffGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
@@ -4012,9 +3992,8 @@ new MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<OnOffGeneratedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4024,14 +4003,14 @@ new MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAcceptedCommandListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<OnOffAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4041,27 +4020,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<OnOffAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAcceptedCommandListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4070,7 +4048,8 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(OnOffAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
@@ -4079,9 +4058,8 @@ new MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<OnOffAcceptedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4091,14 +4069,14 @@ new MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<OnOffAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4107,27 +4085,25 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROnOffAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<OnOffAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROnOffAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROnOffAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROnOffAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROnOffAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4135,7 +4111,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(OnOffAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
@@ -4144,9 +4121,8 @@ new MTROnOffAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancel
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<OnOffAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4156,14 +4132,14 @@ new MTROnOffAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancel
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4172,26 +4148,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4199,7 +4174,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
@@ -4208,9 +4184,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4220,14 +4195,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4236,26 +4211,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4263,7 +4237,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
@@ -4272,9 +4247,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4720,14 +4694,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeSwitchTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSwitchTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4736,26 +4710,25 @@ - (void)subscribeAttributeSwitchTypeWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSwitchTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4763,7 +4736,8 @@ + (void)readAttributeSwitchTypeWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
@@ -4772,9 +4746,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4784,14 +4757,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeSwitchActionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -4806,12 +4779,13 @@ - (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -4823,13 +4797,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSwitchActionsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4838,26 +4810,25 @@ - (void)subscribeAttributeSwitchActionsWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSwitchActionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4865,7 +4836,8 @@ + (void)readAttributeSwitchActionsWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
@@ -4874,9 +4846,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -4886,14 +4857,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4903,30 +4875,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
+
+            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -4935,8 +4905,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
@@ -4945,10 +4916,8 @@ new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -4958,14 +4927,15 @@ new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -4975,30 +4945,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
+
+            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5007,8 +4975,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
@@ -5017,10 +4986,8 @@ new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -5030,14 +4997,15 @@ new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffSwitchConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<OnOffSwitchConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -5046,28 +5014,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<OnOffSwitchConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OnOffSwitchConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5075,8 +5043,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OnOffSwitchConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
@@ -5085,9 +5054,8 @@ new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OnOffSwitchConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -5097,14 +5065,14 @@ new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -5113,26 +5081,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5140,7 +5107,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
@@ -5149,9 +5117,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -5161,14 +5128,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -5177,26 +5144,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5204,7 +5170,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
@@ -5213,9 +5180,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -5505,12 +5471,13 @@ - (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::MoveToLevel::Type request;
@@ -5529,23 +5496,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::Move::Type request;
@@ -5564,23 +5531,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stepWithParams:(MTRLevelControlClusterStepParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::Step::Type request;
@@ -5600,23 +5567,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopWithParams:(MTRLevelControlClusterStopParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::Stop::Type request;
@@ -5628,11 +5595,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params
@@ -5640,12 +5606,13 @@ - (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnO
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::MoveToLevelWithOnOff::Type request;
@@ -5664,23 +5631,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::MoveWithOnOff::Type request;
@@ -5699,23 +5666,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::StepWithOnOff::Type request;
@@ -5735,23 +5702,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::StopWithOnOff::Type request;
@@ -5763,11 +5730,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params
@@ -5775,12 +5741,13 @@ - (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFre
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LevelControl::Commands::MoveToClosestFrequency::Type request;
@@ -5791,23 +5758,22 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.frequency = params.frequency.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -5816,27 +5782,25 @@ - (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5844,7 +5808,8 @@ + (void)readAttributeCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
@@ -5853,9 +5818,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -5865,14 +5829,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -5881,26 +5845,25 @@ - (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5908,7 +5871,8 @@ + (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
@@ -5917,9 +5881,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -5929,14 +5892,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -5945,26 +5908,25 @@ - (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -5972,7 +5934,8 @@ + (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
@@ -5981,9 +5944,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -5993,14 +5955,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6009,26 +5971,25 @@ - (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6036,7 +5997,8 @@ + (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
@@ -6045,9 +6007,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6057,14 +6018,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCurrentFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6073,26 +6034,25 @@ - (void)subscribeAttributeCurrentFrequencyWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6100,7 +6060,8 @@ + (void)readAttributeCurrentFrequencyWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
@@ -6109,9 +6070,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6121,14 +6081,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMinFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6137,26 +6097,25 @@ - (void)subscribeAttributeMinFrequencyWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6164,7 +6123,8 @@ + (void)readAttributeMinFrequencyWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
@@ -6173,9 +6133,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6185,14 +6144,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMaxFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6201,26 +6160,25 @@ - (void)subscribeAttributeMaxFrequencyWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6228,7 +6186,8 @@ + (void)readAttributeMaxFrequencyWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
@@ -6237,9 +6196,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6249,14 +6207,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -6271,12 +6229,13 @@ - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6288,13 +6247,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOptionsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6303,26 +6260,25 @@ - (void)subscribeAttributeOptionsWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6330,7 +6286,8 @@ + (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
@@ -6339,9 +6296,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6351,14 +6307,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeOnOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -6373,12 +6329,13 @@ - (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6390,13 +6347,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOnOffTransitionTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6406,26 +6361,25 @@ - (void)subscribeAttributeOnOffTransitionTimeWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOnOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6434,7 +6388,8 @@ + (void)readAttributeOnOffTransitionTimeWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
@@ -6443,9 +6398,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6455,14 +6409,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOnLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -6477,12 +6431,13 @@ - (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6499,13 +6454,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOnLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6514,27 +6467,25 @@ - (void)subscribeAttributeOnLevelWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOnLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6542,7 +6493,8 @@ + (void)readAttributeOnLevelWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
@@ -6551,9 +6503,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6563,14 +6514,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeOnTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -6585,12 +6536,13 @@ - (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6607,13 +6559,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOnTransitionTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6622,27 +6572,25 @@ - (void)subscribeAttributeOnTransitionTimeWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOnTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6650,7 +6598,8 @@ + (void)readAttributeOnTransitionTimeWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
@@ -6659,9 +6608,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6671,14 +6619,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -6693,12 +6641,13 @@ - (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6715,13 +6664,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOffTransitionTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6730,27 +6677,25 @@ - (void)subscribeAttributeOffTransitionTimeWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6758,7 +6703,8 @@ + (void)readAttributeOffTransitionTimeWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
@@ -6767,9 +6713,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6779,14 +6724,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeDefaultMoveRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -6801,12 +6746,13 @@ - (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6823,13 +6769,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDefaultMoveRateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6838,27 +6782,25 @@ - (void)subscribeAttributeDefaultMoveRateWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDefaultMoveRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6866,7 +6808,8 @@ + (void)readAttributeDefaultMoveRateWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
@@ -6875,9 +6818,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6887,14 +6829,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeStartUpCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -6909,12 +6851,13 @@ - (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -6931,13 +6874,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStartUpCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -6947,27 +6888,25 @@ - (void)subscribeAttributeStartUpCurrentLevelWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStartUpCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -6976,7 +6915,8 @@ + (void)readAttributeStartUpCurrentLevelWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
@@ -6985,9 +6925,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -6997,14 +6936,15 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LevelControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<LevelControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -7014,27 +6954,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<LevelControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LevelControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -7043,8 +6983,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LevelControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
@@ -7053,9 +6994,8 @@ new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<LevelControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -7065,14 +7005,15 @@ new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LevelControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<LevelControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -7082,27 +7023,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<LevelControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LevelControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -7111,8 +7052,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LevelControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
@@ -7121,9 +7063,8 @@ new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<LevelControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -7133,14 +7074,14 @@ new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLevelControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLevelControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LevelControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<LevelControlAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -7149,27 +7090,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<LevelControlAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LevelControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -7177,7 +7117,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLevelControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLevelControlAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(LevelControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
@@ -7186,9 +7127,8 @@ new MTRLevelControlAttributeListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<LevelControlAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -7198,14 +7138,14 @@ new MTRLevelControlAttributeListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -7214,26 +7154,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -7241,7 +7180,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
@@ -7250,9 +7190,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -7262,14 +7201,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -7278,26 +7217,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -7305,7 +7243,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
@@ -7314,9 +7253,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8122,14 +8060,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeActiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -8144,12 +8082,13 @@ - (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -8161,13 +8100,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveTextWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8176,27 +8113,25 @@ - (void)subscribeAttributeActiveTextWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
 
-                chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8204,7 +8139,8 @@ + (void)readAttributeActiveTextWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
@@ -8213,9 +8149,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8225,14 +8160,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -8247,12 +8182,13 @@ - (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -8264,13 +8200,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8279,27 +8213,25 @@ - (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
 
-                chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8307,7 +8239,8 @@ + (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
@@ -8316,9 +8249,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8328,14 +8260,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeInactiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -8350,12 +8282,13 @@ - (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -8367,13 +8300,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInactiveTextWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8382,27 +8313,25 @@ - (void)subscribeAttributeInactiveTextWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
 
-                chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInactiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8410,7 +8339,8 @@ + (void)readAttributeInactiveTextWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
@@ -8419,9 +8349,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8431,14 +8360,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeOutOfServiceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -8453,12 +8382,13 @@ - (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -8470,13 +8400,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOutOfServiceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8485,26 +8413,25 @@ - (void)subscribeAttributeOutOfServiceWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOutOfServiceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8512,7 +8439,8 @@ + (void)readAttributeOutOfServiceWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
@@ -8521,9 +8449,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8533,14 +8460,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePolarityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePolarityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8549,26 +8476,25 @@ - (void)subscribeAttributePolarityWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePolarityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8576,7 +8502,8 @@ + (void)readAttributePolarityWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
@@ -8585,9 +8512,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8597,14 +8523,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributePresentValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -8619,12 +8545,13 @@ - (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -8636,13 +8563,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePresentValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8651,26 +8576,25 @@ - (void)subscribeAttributePresentValueWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePresentValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8678,7 +8602,8 @@ + (void)readAttributePresentValueWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
@@ -8687,9 +8612,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8699,14 +8623,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReliabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -8721,12 +8645,13 @@ - (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -8738,13 +8663,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReliabilityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8753,26 +8676,25 @@ - (void)subscribeAttributeReliabilityWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReliabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8780,7 +8702,8 @@ + (void)readAttributeReliabilityWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
@@ -8789,9 +8712,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8801,14 +8723,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeStatusFlagsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStatusFlagsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8817,26 +8739,25 @@ - (void)subscribeAttributeStatusFlagsWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStatusFlagsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8844,7 +8765,8 @@ + (void)readAttributeStatusFlagsWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
@@ -8853,9 +8775,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8865,14 +8786,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeApplicationTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApplicationTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8881,26 +8802,25 @@ - (void)subscribeAttributeApplicationTypeWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApplicationTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8908,7 +8828,8 @@ + (void)readAttributeApplicationTypeWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
@@ -8917,9 +8838,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -8929,14 +8849,15 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BinaryInputBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BinaryInputBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -8946,28 +8867,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BinaryInputBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BinaryInputBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -8976,8 +8897,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BinaryInputBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
@@ -8986,9 +8908,8 @@ new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BinaryInputBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -8998,14 +8919,15 @@ new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BinaryInputBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BinaryInputBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9015,28 +8937,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BinaryInputBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BinaryInputBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -9045,8 +8967,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BinaryInputBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
@@ -9055,9 +8978,8 @@ new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BinaryInputBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -9067,14 +8989,15 @@ new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BinaryInputBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BinaryInputBasicAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9083,27 +9006,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BinaryInputBasicAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BinaryInputBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -9111,8 +9034,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BinaryInputBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
@@ -9121,9 +9045,8 @@ new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BinaryInputBasicAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -9133,14 +9056,14 @@ new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9149,26 +9072,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -9176,7 +9098,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
@@ -9185,9 +9108,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -9197,14 +9119,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9213,26 +9135,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -9240,7 +9161,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
@@ -9249,9 +9171,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -9826,14 +9747,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeDeviceTypeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorDeviceTypeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
-            auto successFn = Callback<DescriptorDeviceTypeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDeviceTypeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9842,27 +9763,26 @@ - (void)subscribeAttributeDeviceTypeListWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
-                auto successFn = Callback<DescriptorDeviceTypeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorDeviceTypeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDeviceTypeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -9870,7 +9790,8 @@ + (void)readAttributeDeviceTypeListWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DescriptorDeviceTypeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
@@ -9879,9 +9800,8 @@ new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DescriptorDeviceTypeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -9891,14 +9811,14 @@ new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeServerListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorServerListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorServerListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorServerListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
-            auto successFn = Callback<DescriptorServerListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeServerListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9907,27 +9827,26 @@ - (void)subscribeAttributeServerListWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorServerListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
-                auto successFn = Callback<DescriptorServerListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorServerListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorServerListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorServerListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorServerListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorServerListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeServerListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -9935,7 +9854,8 @@ + (void)readAttributeServerListWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorServerListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorServerListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DescriptorServerListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
@@ -9944,9 +9864,8 @@ new MTRDescriptorServerListListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DescriptorServerListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -9956,14 +9875,14 @@ new MTRDescriptorServerListListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributeClientListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorClientListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorClientListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorClientListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
-            auto successFn = Callback<DescriptorClientListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClientListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -9972,27 +9891,26 @@ - (void)subscribeAttributeClientListWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorClientListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
-                auto successFn = Callback<DescriptorClientListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorClientListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorClientListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorClientListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorClientListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorClientListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClientListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10000,7 +9918,8 @@ + (void)readAttributeClientListWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorClientListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorClientListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DescriptorClientListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
@@ -10009,9 +9928,8 @@ new MTRDescriptorClientListListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DescriptorClientListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -10021,14 +9939,14 @@ new MTRDescriptorClientListListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributePartsListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorPartsListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorPartsListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorPartsListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
-            auto successFn = Callback<DescriptorPartsListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePartsListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10037,27 +9955,26 @@ - (void)subscribeAttributePartsListWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
-                auto successFn = Callback<DescriptorPartsListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorPartsListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePartsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10065,7 +9982,8 @@ + (void)readAttributePartsListWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorPartsListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorPartsListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DescriptorPartsListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
@@ -10074,9 +9992,8 @@ new MTRDescriptorPartsListListAttributeCallbackBridge(queue, completion, ^(Cance
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DescriptorPartsListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -10086,14 +10003,15 @@ new MTRDescriptorPartsListListAttributeCallbackBridge(queue, completion, ^(Cance
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DescriptorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<DescriptorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10103,27 +10021,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<DescriptorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DescriptorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10132,8 +10050,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DescriptorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
@@ -10142,9 +10061,8 @@ new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DescriptorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -10154,14 +10072,15 @@ new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DescriptorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<DescriptorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10171,27 +10090,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<DescriptorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DescriptorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10200,8 +10119,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DescriptorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
@@ -10210,9 +10130,8 @@ new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DescriptorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -10222,14 +10141,14 @@ new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<DescriptorAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10238,27 +10157,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<DescriptorAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10266,7 +10184,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDescriptorAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDescriptorAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DescriptorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
@@ -10275,9 +10194,8 @@ new MTRDescriptorAttributeListListAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DescriptorAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -10287,14 +10205,14 @@ new MTRDescriptorAttributeListListAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10303,26 +10221,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10330,7 +10247,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
@@ -10339,9 +10257,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -10351,14 +10268,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10367,26 +10284,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10394,7 +10310,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
@@ -10403,9 +10320,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -10749,15 +10665,14 @@ - (void)readAttributeBindingWithParams:(MTRReadParams * _Nullable)params
                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTRBindingBindingListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBindingBindingListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingBindingListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Binding::Attributes::Binding::TypeInfo;
-            auto successFn = Callback<BindingBindingListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -10772,12 +10687,13 @@ - (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -10826,13 +10742,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBindingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10841,27 +10755,25 @@ - (void)subscribeAttributeBindingWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBindingBindingListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBindingBindingListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Binding::Attributes::Binding::TypeInfo;
-                auto successFn = Callback<BindingBindingListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBindingBindingListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingBindingListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBindingBindingListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
 
-                chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBindingBindingListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBindingBindingListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBindingBindingListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBindingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10869,7 +10781,8 @@ + (void)readAttributeBindingWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingBindingListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBindingBindingListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BindingBindingListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Binding::Attributes::Binding::TypeInfo;
@@ -10878,9 +10791,8 @@ new MTRBindingBindingListAttributeCallbackBridge(queue, completion, ^(Cancelable
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BindingBindingListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -10890,14 +10802,15 @@ new MTRBindingBindingListAttributeCallbackBridge(queue, completion, ^(Cancelable
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBindingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BindingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BindingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10907,27 +10820,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BindingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BindingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -10936,35 +10849,36 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BindingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BindingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBindingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BindingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BindingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -10974,27 +10888,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BindingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BindingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11003,35 +10916,36 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BindingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BindingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBindingAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BindingAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11040,27 +10954,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBindingAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BindingAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBindingAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBindingAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBindingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBindingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11068,7 +10981,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBindingAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBindingAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BindingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
@@ -11077,9 +10991,8 @@ new MTRBindingAttributeListListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BindingAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11089,14 +11002,14 @@ new MTRBindingAttributeListListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11105,26 +11018,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11132,7 +11044,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
@@ -11141,9 +11054,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11153,14 +11065,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11169,26 +11081,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11196,7 +11107,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
@@ -11205,9 +11117,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11462,15 +11373,14 @@ - (void)readAttributeAclWithParams:(MTRReadParams * _Nullable)params
                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTRAccessControlAclListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlAclListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlAclListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
-            auto successFn = Callback<AccessControlAclListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeAclWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -11485,12 +11395,13 @@ - (void)writeAttributeAclWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -11600,13 +11511,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAclWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11615,27 +11524,25 @@ - (void)subscribeAttributeAclWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccessControlAclListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccessControlAclListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
-                auto successFn = Callback<AccessControlAclListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccessControlAclListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlAclListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccessControlAclListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
 
-                chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccessControlAclListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccessControlAclListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccessControlAclListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAclWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11643,7 +11550,8 @@ + (void)readAttributeAclWithAttributeCache:(MTRAttributeCacheContainer *)attribu
                                      queue:(dispatch_queue_t)queue
                                 completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlAclListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlAclListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(AccessControlAclListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
@@ -11652,9 +11560,8 @@ new MTRAccessControlAclListAttributeCallbackBridge(queue, completion, ^(Cancelab
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<AccessControlAclListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11666,15 +11573,14 @@ - (void)readAttributeExtensionWithParams:(MTRReadParams * _Nullable)params
                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTRAccessControlExtensionListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlExtensionListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlExtensionListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
-            auto successFn = Callback<AccessControlExtensionListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -11689,12 +11595,13 @@ - (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -11728,13 +11635,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeExtensionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11743,27 +11648,26 @@ - (void)subscribeAttributeExtensionWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
-                auto successFn = Callback<AccessControlExtensionListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlExtensionListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
 
-                chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeExtensionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11771,7 +11675,8 @@ + (void)readAttributeExtensionWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlExtensionListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlExtensionListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(AccessControlExtensionListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
@@ -11780,9 +11685,8 @@ new MTRAccessControlExtensionListAttributeCallbackBridge(queue, completion, ^(Ca
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<AccessControlExtensionListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11793,14 +11697,14 @@ new MTRAccessControlExtensionListAttributeCallbackBridge(queue, completion, ^(Ca
 - (void)readAttributeSubjectsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSubjectsPerAccessControlEntryWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11811,26 +11715,25 @@ - (void)subscribeAttributeSubjectsPerAccessControlEntryWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSubjectsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11839,7 +11742,8 @@ + (void)readAttributeSubjectsPerAccessControlEntryWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
@@ -11848,9 +11752,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11861,14 +11764,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeTargetsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTargetsPerAccessControlEntryWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11879,26 +11782,25 @@ - (void)subscribeAttributeTargetsPerAccessControlEntryWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTargetsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11907,7 +11809,8 @@ + (void)readAttributeTargetsPerAccessControlEntryWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
@@ -11916,9 +11819,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11929,14 +11831,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAccessControlEntriesPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAccessControlEntriesPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -11947,26 +11849,25 @@ - (void)subscribeAttributeAccessControlEntriesPerFabricWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAccessControlEntriesPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -11975,7 +11876,8 @@ + (void)readAttributeAccessControlEntriesPerFabricWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
@@ -11984,9 +11886,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -11996,14 +11897,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccessControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<AccessControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -12013,27 +11915,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<AccessControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccessControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -12042,8 +11944,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AccessControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
@@ -12052,9 +11955,8 @@ new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AccessControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -12064,14 +11966,15 @@ new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccessControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<AccessControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -12081,27 +11984,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<AccessControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccessControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -12110,8 +12013,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AccessControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
@@ -12120,9 +12024,8 @@ new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AccessControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -12132,14 +12035,14 @@ new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccessControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccessControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<AccessControlAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -12148,27 +12051,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<AccessControlAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccessControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -12176,35 +12078,36 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccessControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<AccessControlAttributeListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRAccessControlAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AccessControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -12213,26 +12116,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -12240,7 +12142,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
@@ -12249,9 +12152,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -12261,14 +12163,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -12277,26 +12179,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -12304,7 +12205,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
@@ -12313,9 +12215,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -12718,12 +12619,13 @@ - (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params c
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::InstantAction::Type request;
@@ -12738,11 +12640,10 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWithTransitionParams *)params
@@ -12750,12 +12651,13 @@ - (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWit
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::InstantActionWithTransition::Type request;
@@ -12771,23 +12673,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.transitionTime = params.transitionTime.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::StartAction::Type request;
@@ -12802,11 +12704,10 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurationParams *)params
@@ -12814,12 +12715,13 @@ - (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurat
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::StartActionWithDuration::Type request;
@@ -12835,23 +12737,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.duration = params.duration.unsignedIntValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::StopAction::Type request;
@@ -12866,23 +12768,23 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::PauseAction::Type request;
@@ -12897,11 +12799,10 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurationParams *)params
@@ -12909,12 +12810,13 @@ - (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurat
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::PauseActionWithDuration::Type request;
@@ -12930,23 +12832,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.duration = params.duration.unsignedIntValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::ResumeAction::Type request;
@@ -12961,23 +12863,23 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::EnableAction::Type request;
@@ -12992,11 +12894,10 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDurationParams *)params
@@ -13004,12 +12905,13 @@ - (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDur
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::EnableActionWithDuration::Type request;
@@ -13025,23 +12927,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.duration = params.duration.unsignedIntValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::DisableAction::Type request;
@@ -13056,11 +12958,10 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = params.invokeID.unsignedIntValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithDurationParams *)params
@@ -13068,12 +12969,13 @@ - (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithD
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Actions::Commands::DisableActionWithDuration::Type request;
@@ -13089,23 +12991,22 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.duration = params.duration.unsignedIntValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeActionListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsActionListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsActionListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsActionListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
-            auto successFn = Callback<ActionsActionListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActionListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13114,27 +13015,25 @@ - (void)subscribeAttributeActionListWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRActionsActionListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRActionsActionListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
-                auto successFn = Callback<ActionsActionListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRActionsActionListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsActionListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRActionsActionListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
 
-                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRActionsActionListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRActionsActionListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRActionsActionListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActionListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13142,7 +13041,8 @@ + (void)readAttributeActionListWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsActionListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsActionListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ActionsActionListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
@@ -13151,9 +13051,8 @@ new MTRActionsActionListListAttributeCallbackBridge(queue, completion, ^(Cancela
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ActionsActionListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -13163,14 +13062,14 @@ new MTRActionsActionListListAttributeCallbackBridge(queue, completion, ^(Cancela
 
 - (void)readAttributeEndpointListsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsEndpointListsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsEndpointListsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsEndpointListsListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
-            auto successFn = Callback<ActionsEndpointListsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEndpointListsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13179,27 +13078,26 @@ - (void)subscribeAttributeEndpointListsWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
-                auto successFn = Callback<ActionsEndpointListsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsEndpointListsListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
 
-                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEndpointListsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13207,7 +13105,8 @@ + (void)readAttributeEndpointListsWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsEndpointListsListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsEndpointListsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ActionsEndpointListsListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
@@ -13216,9 +13115,8 @@ new MTRActionsEndpointListsListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ActionsEndpointListsListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -13228,14 +13126,14 @@ new MTRActionsEndpointListsListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributeSetupURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSetupURLWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13244,27 +13142,25 @@ - (void)subscribeAttributeSetupURLWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
 
-                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSetupURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13272,7 +13168,8 @@ + (void)readAttributeSetupURLWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
@@ -13281,9 +13178,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -13293,14 +13189,15 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ActionsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ActionsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13310,27 +13207,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ActionsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ActionsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13339,35 +13236,36 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ActionsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ActionsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ActionsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ActionsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13377,27 +13275,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ActionsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ActionsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13406,35 +13303,36 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ActionsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ActionsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ActionsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13443,27 +13341,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRActionsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ActionsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRActionsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRActionsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRActionsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRActionsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13471,7 +13368,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRActionsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRActionsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ActionsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
@@ -13480,9 +13378,8 @@ new MTRActionsAttributeListListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ActionsAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -13492,14 +13389,14 @@ new MTRActionsAttributeListListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13508,26 +13405,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13535,7 +13431,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
@@ -13544,9 +13441,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -13556,14 +13452,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -13572,26 +13468,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -13599,7 +13494,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
@@ -13608,9 +13504,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -13985,12 +13880,13 @@ - (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nulla
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Basic::Commands::MfgSpecificPing::Type request;
@@ -14000,23 +13896,22 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeDataModelRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDataModelRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14025,26 +13920,25 @@ - (void)subscribeAttributeDataModelRevisionWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDataModelRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14052,7 +13946,8 @@ + (void)readAttributeDataModelRevisionWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
@@ -14061,9 +13956,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14073,14 +13967,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14089,27 +13983,25 @@ - (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14117,7 +14009,8 @@ + (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
@@ -14126,9 +14019,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14138,14 +14030,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14154,26 +14046,25 @@ - (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRVendorIdAttributeCallbackSubscriptionBridge * callbackBridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRVendorIdAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14181,7 +14072,8 @@ + (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
@@ -14190,9 +14082,8 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14202,14 +14093,14 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
 
 - (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14218,27 +14109,25 @@ - (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14246,7 +14135,8 @@ + (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
@@ -14255,9 +14145,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14267,14 +14156,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14283,26 +14172,25 @@ - (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14310,7 +14198,8 @@ + (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
@@ -14319,9 +14208,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14331,14 +14219,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -14353,12 +14241,13 @@ - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -14370,13 +14259,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNodeLabelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14385,27 +14272,25 @@ - (void)subscribeAttributeNodeLabelWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14413,7 +14298,8 @@ + (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
@@ -14422,9 +14308,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14434,14 +14319,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeLocationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::Location::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -14456,12 +14341,13 @@ - (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -14473,13 +14359,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Basic::Attributes::Location::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLocationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14488,27 +14372,25 @@ - (void)subscribeAttributeLocationWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::Location::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::Location::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLocationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14516,7 +14398,8 @@ + (void)readAttributeLocationWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::Location::TypeInfo;
@@ -14525,9 +14408,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14537,14 +14419,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14553,26 +14435,25 @@ - (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14580,7 +14461,8 @@ + (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
@@ -14589,9 +14471,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14601,14 +14482,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14618,27 +14499,25 @@ - (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14647,7 +14526,8 @@ + (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
@@ -14656,9 +14536,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14668,14 +14547,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14684,26 +14563,25 @@ - (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14711,7 +14589,8 @@ + (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
@@ -14720,9 +14599,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14732,14 +14610,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14749,27 +14627,25 @@ - (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14778,7 +14654,8 @@ + (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
@@ -14787,9 +14664,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14799,14 +14675,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14815,27 +14691,25 @@ - (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14843,7 +14717,8 @@ + (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
@@ -14852,9 +14727,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14864,14 +14738,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14880,27 +14754,25 @@ - (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14908,7 +14780,8 @@ + (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
@@ -14917,9 +14790,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14929,14 +14801,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -14945,27 +14817,25 @@ - (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -14973,7 +14843,8 @@ + (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
@@ -14982,9 +14853,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -14994,14 +14864,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15010,27 +14880,25 @@ - (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15038,7 +14906,8 @@ + (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
@@ -15047,9 +14916,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15059,14 +14927,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15075,27 +14943,25 @@ - (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15103,7 +14969,8 @@ + (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
@@ -15112,9 +14979,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15124,14 +14990,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeLocalConfigDisabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -15146,12 +15012,13 @@ - (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -15163,13 +15030,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLocalConfigDisabledWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15179,26 +15044,25 @@ - (void)subscribeAttributeLocalConfigDisabledWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLocalConfigDisabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15207,7 +15071,8 @@ + (void)readAttributeLocalConfigDisabledWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
@@ -15216,9 +15081,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15228,14 +15092,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15244,26 +15108,25 @@ - (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15271,7 +15134,8 @@ + (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
@@ -15280,9 +15144,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15292,14 +15155,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15308,27 +15171,25 @@ - (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15336,7 +15197,8 @@ + (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
@@ -15345,9 +15207,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15358,14 +15219,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 - (void)readAttributeCapabilityMinimaWithCompletion:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                         NSError * _Nullable error))completion
 {
-    new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicCapabilityMinimaStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
-            auto successFn = Callback<BasicCapabilityMinimaStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCapabilityMinimaWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15375,27 +15236,26 @@ - (void)subscribeAttributeCapabilityMinimaWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
-                auto successFn = Callback<BasicCapabilityMinimaStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicCapabilityMinimaStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCapabilityMinimaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15404,7 +15264,8 @@ + (void)readAttributeCapabilityMinimaWithAttributeCache:(MTRAttributeCacheContai
                                              completion:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                             NSError * _Nullable error))completion
 {
-    new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BasicCapabilityMinimaStructAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
@@ -15413,9 +15274,8 @@ new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BasicCapabilityMinimaStructAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15425,14 +15285,14 @@ new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15442,27 +15302,26 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15471,7 +15330,8 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
@@ -15480,9 +15340,8 @@ new MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15492,14 +15351,14 @@ new MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAcceptedCommandListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15509,27 +15368,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAcceptedCommandListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15538,7 +15396,8 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
@@ -15547,9 +15406,8 @@ new MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15559,14 +15417,14 @@ new MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BasicAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15575,27 +15433,25 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBasicAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BasicAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBasicAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15603,7 +15459,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBasicAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBasicAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
@@ -15612,9 +15469,8 @@ new MTRBasicAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancel
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BasicAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15624,14 +15480,14 @@ new MTRBasicAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancel
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15640,26 +15496,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15667,7 +15522,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
@@ -15676,9 +15532,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -15688,14 +15543,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -15704,26 +15559,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -15731,7 +15585,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
@@ -15740,9 +15595,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -16682,8 +16536,10 @@ - (void)queryImageWithParams:(MTROtaSoftwareUpdateProviderClusterQueryImageParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OtaSoftwareUpdateProvider::Commands::QueryImage::Type request;
@@ -16735,11 +16591,10 @@ new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.cal
                 definedValue_0 = [self asByteSpan:params.metadataForProvider];
             }
 
-            auto successFn = Callback<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUpdateRequestParams *)params
@@ -16748,8 +16603,10 @@ - (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUp
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type request;
@@ -16761,11 +16618,10 @@ new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.ca
             request.updateToken = [self asByteSpan:params.updateToken];
             request.newVersion = params.newVersion.unsignedIntValue;
 
-            auto successFn = Callback<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
@@ -16773,12 +16629,13 @@ - (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotify
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type request;
@@ -16790,23 +16647,23 @@ new MTRCommandSuccessCallbackBridge(
             request.updateToken = [self asByteSpan:params.updateToken];
             request.softwareVersion = params.softwareVersion.unsignedIntValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -16816,30 +16673,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
+
+            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -16848,8 +16703,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
@@ -16858,10 +16714,8 @@ new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -16871,14 +16725,15 @@ new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -16888,30 +16743,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
+
+            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -16920,8 +16773,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
@@ -16930,10 +16784,8 @@ new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -16943,14 +16795,15 @@ new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -16959,28 +16812,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateProviderAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -16988,8 +16841,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateProviderAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
@@ -16998,9 +16852,8 @@ new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -17010,14 +16863,14 @@ new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17026,26 +16879,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17053,7 +16905,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
@@ -17062,9 +16915,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -17074,14 +16926,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17090,26 +16942,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17117,7 +16968,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
@@ -17126,9 +16978,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -17359,12 +17210,13 @@ - (void)announceOtaProviderWithParams:(MTROtaSoftwareUpdateRequestorClusterAnnou
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Type request;
@@ -17383,26 +17235,25 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.endpoint = params.endpoint.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeDefaultOtaProvidersWithParams:(MTRReadParams * _Nullable)params
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -17417,12 +17268,13 @@ - (void)writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -17457,13 +17309,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDefaultOtaProvidersWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17473,30 +17323,28 @@ - (void)subscribeAttributeDefaultOtaProvidersWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDefaultOtaProvidersWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17505,8 +17353,9 @@ + (void)readAttributeDefaultOtaProvidersWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
@@ -17515,10 +17364,8 @@ new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -17528,14 +17375,14 @@ new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(
 
 - (void)readAttributeUpdatePossibleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUpdatePossibleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17544,26 +17391,25 @@ - (void)subscribeAttributeUpdatePossibleWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUpdatePossibleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17571,7 +17417,8 @@ + (void)readAttributeUpdatePossibleWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
@@ -17580,9 +17427,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -17592,15 +17438,16 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeUpdateStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
-            auto successFn
-                = Callback<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
+                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUpdateStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17609,30 +17456,29 @@ - (void)subscribeAttributeUpdateStateWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUpdateStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17640,8 +17486,9 @@ + (void)readAttributeUpdateStateWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
@@ -17650,10 +17497,8 @@ new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridg
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -17663,14 +17508,14 @@ new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridg
 
 - (void)readAttributeUpdateStateProgressWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUpdateStateProgressWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17680,27 +17525,25 @@ - (void)subscribeAttributeUpdateStateProgressWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUpdateStateProgressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17709,7 +17552,8 @@ + (void)readAttributeUpdateStateProgressWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
@@ -17718,9 +17562,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -17730,14 +17573,15 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17747,30 +17591,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17779,8 +17621,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
@@ -17789,10 +17632,8 @@ new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -17802,14 +17643,15 @@ new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17819,30 +17661,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17851,8 +17691,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
@@ -17861,10 +17702,8 @@ new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -17874,14 +17713,15 @@ new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17890,28 +17730,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OtaSoftwareUpdateRequestorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17919,8 +17759,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OtaSoftwareUpdateRequestorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
@@ -17929,9 +17770,8 @@ new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -17941,14 +17781,14 @@ new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -17957,26 +17797,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -17984,7 +17823,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
@@ -17993,9 +17833,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -18005,14 +17844,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18021,26 +17860,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18048,7 +17886,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
@@ -18057,9 +17896,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -18427,14 +18265,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeActiveLocaleWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -18449,12 +18287,13 @@ - (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -18466,13 +18305,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveLocaleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18481,27 +18318,25 @@ - (void)subscribeAttributeActiveLocaleWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
 
-                chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveLocaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18509,7 +18344,8 @@ + (void)readAttributeActiveLocaleWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
@@ -18518,9 +18354,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -18530,14 +18365,15 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeSupportedLocalesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationSupportedLocalesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
-            auto successFn = Callback<LocalizationConfigurationSupportedLocalesListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportedLocalesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18546,28 +18382,28 @@ - (void)subscribeAttributeSupportedLocalesWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
-                auto successFn = Callback<LocalizationConfigurationSupportedLocalesListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationSupportedLocalesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
 
-                chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportedLocalesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18575,8 +18411,9 @@ + (void)readAttributeSupportedLocalesWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LocalizationConfigurationSupportedLocalesListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
@@ -18585,9 +18422,8 @@ new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<LocalizationConfigurationSupportedLocalesListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -18597,14 +18433,15 @@ new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<LocalizationConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18614,30 +18451,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<LocalizationConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
+
+            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18646,8 +18481,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LocalizationConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
@@ -18656,10 +18492,8 @@ new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<LocalizationConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -18669,14 +18503,15 @@ new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<LocalizationConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18686,30 +18521,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<LocalizationConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
+
+            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18718,8 +18551,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LocalizationConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
@@ -18728,10 +18562,8 @@ new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<LocalizationConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -18741,14 +18573,15 @@ new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<LocalizationConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18757,28 +18590,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<LocalizationConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LocalizationConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18786,8 +18619,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LocalizationConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
@@ -18796,9 +18630,8 @@ new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<LocalizationConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -18808,14 +18641,14 @@ new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18824,26 +18657,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18851,7 +18683,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
@@ -18860,9 +18693,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -18872,14 +18704,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -18888,26 +18720,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -18915,7 +18746,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
@@ -18924,9 +18756,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -19215,14 +19046,15 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeHourFormatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationClusterHourFormatAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
-            auto successFn = Callback<TimeFormatLocalizationClusterHourFormatAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -19237,12 +19069,13 @@ - (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -19254,13 +19087,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHourFormatWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19269,28 +19100,28 @@ - (void)subscribeAttributeHourFormatWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
-                auto successFn = Callback<TimeFormatLocalizationClusterHourFormatAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationClusterHourFormatAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
 
-                chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHourFormatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19298,8 +19129,9 @@ + (void)readAttributeHourFormatWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TimeFormatLocalizationClusterHourFormatAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
@@ -19308,9 +19140,8 @@ new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TimeFormatLocalizationClusterHourFormatAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -19320,14 +19151,15 @@ new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(
 
 - (void)readAttributeActiveCalendarTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationClusterCalendarTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
-            auto successFn = Callback<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -19342,12 +19174,13 @@ - (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -19359,13 +19192,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveCalendarTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19375,28 +19206,28 @@ - (void)subscribeAttributeActiveCalendarTypeWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
-                auto successFn = Callback<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationClusterCalendarTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
 
-                chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveCalendarTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19405,8 +19236,9 @@ + (void)readAttributeActiveCalendarTypeWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TimeFormatLocalizationClusterCalendarTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
@@ -19415,9 +19247,8 @@ new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -19427,14 +19258,15 @@ new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(
 
 - (void)readAttributeSupportedCalendarTypesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
-            auto successFn = Callback<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportedCalendarTypesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19444,30 +19276,28 @@ - (void)subscribeAttributeSupportedCalendarTypesWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
-                auto successFn
-                    = Callback<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
+
+            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportedCalendarTypesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19476,8 +19306,9 @@ + (void)readAttributeSupportedCalendarTypesWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
@@ -19486,10 +19317,8 @@ new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -19499,14 +19328,15 @@ new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19516,28 +19346,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19546,8 +19376,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TimeFormatLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
@@ -19556,9 +19387,8 @@ new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -19568,14 +19398,15 @@ new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19585,28 +19416,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19615,8 +19446,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TimeFormatLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
@@ -19625,9 +19457,8 @@ new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -19637,14 +19468,15 @@ new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<TimeFormatLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19653,28 +19485,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<TimeFormatLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TimeFormatLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19682,8 +19514,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TimeFormatLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
@@ -19692,9 +19525,8 @@ new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TimeFormatLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -19704,14 +19536,14 @@ new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19720,26 +19552,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19747,7 +19578,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
@@ -19756,9 +19588,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -19768,14 +19599,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -19784,26 +19615,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -19811,7 +19641,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
@@ -19820,9 +19651,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -20158,14 +19988,15 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeTemperatureUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationClusterTempUnitAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
-            auto successFn = Callback<UnitLocalizationClusterTempUnitAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -20180,12 +20011,13 @@ - (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -20197,13 +20029,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTemperatureUnitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20212,27 +20042,27 @@ - (void)subscribeAttributeTemperatureUnitWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
-                auto successFn = Callback<UnitLocalizationClusterTempUnitAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationClusterTempUnitAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
 
-                chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTemperatureUnitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20240,35 +20070,37 @@ + (void)readAttributeTemperatureUnitWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<UnitLocalizationClusterTempUnitAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(UnitLocalizationClusterTempUnitAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<UnitLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20278,28 +20110,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<UnitLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20308,8 +20140,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(UnitLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
@@ -20318,9 +20151,8 @@ new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<UnitLocalizationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -20330,14 +20162,15 @@ new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<UnitLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20347,28 +20180,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<UnitLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20377,8 +20210,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(UnitLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
@@ -20387,9 +20221,8 @@ new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<UnitLocalizationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -20399,14 +20232,15 @@ new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<UnitLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20415,27 +20249,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<UnitLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UnitLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20443,8 +20277,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(UnitLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
@@ -20453,9 +20288,8 @@ new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<UnitLocalizationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -20465,14 +20299,14 @@ new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20481,26 +20315,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20508,7 +20341,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
@@ -20517,9 +20351,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -20529,14 +20362,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20545,26 +20378,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20572,7 +20404,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
@@ -20581,9 +20414,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -20838,14 +20670,15 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeSourcesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationSourcesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
-            auto successFn = Callback<PowerSourceConfigurationSourcesListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSourcesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20854,27 +20687,27 @@ - (void)subscribeAttributeSourcesWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
-                auto successFn = Callback<PowerSourceConfigurationSourcesListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationSourcesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
 
-                chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSourcesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20882,8 +20715,9 @@ + (void)readAttributeSourcesWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceConfigurationSourcesListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
@@ -20892,9 +20726,8 @@ new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceConfigurationSourcesListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -20904,14 +20737,15 @@ new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20921,30 +20755,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
+
+            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -20953,8 +20785,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
@@ -20963,10 +20796,8 @@ new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -20976,14 +20807,15 @@ new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -20993,30 +20825,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
+
+            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21025,8 +20855,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
@@ -21035,10 +20866,8 @@ new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -21048,14 +20877,15 @@ new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<PowerSourceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21064,28 +20894,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<PowerSourceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21093,8 +20923,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
@@ -21103,9 +20934,8 @@ new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -21115,14 +20945,14 @@ new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21131,26 +20961,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21158,7 +20987,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
@@ -21167,9 +20997,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21179,14 +21008,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21195,26 +21024,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21222,7 +21050,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
@@ -21231,9 +21060,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21475,14 +21303,15 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterPowerSourceStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
-            auto successFn = Callback<PowerSourceClusterPowerSourceStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21491,27 +21320,27 @@ - (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
-                auto successFn = Callback<PowerSourceClusterPowerSourceStatusAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterPowerSourceStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21519,8 +21348,9 @@ + (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceClusterPowerSourceStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
@@ -21529,9 +21359,8 @@ new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceClusterPowerSourceStatusAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -21541,14 +21370,14 @@ new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(
 
 - (void)readAttributeOrderWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOrderWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21557,26 +21386,25 @@ - (void)subscribeAttributeOrderWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOrderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21584,7 +21412,8 @@ + (void)readAttributeOrderWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
@@ -21593,9 +21422,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21605,14 +21433,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21621,27 +21449,25 @@ - (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21649,7 +21475,8 @@ + (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
@@ -21658,9 +21485,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21671,14 +21497,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 - (void)readAttributeWiredAssessedInputVoltageWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredAssessedInputVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21688,27 +21514,25 @@ - (void)subscribeAttributeWiredAssessedInputVoltageWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredAssessedInputVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21717,7 +21541,8 @@ + (void)readAttributeWiredAssessedInputVoltageWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
@@ -21726,9 +21551,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21739,14 +21563,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeWiredAssessedInputFrequencyWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredAssessedInputFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21756,27 +21580,25 @@ - (void)subscribeAttributeWiredAssessedInputFrequencyWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredAssessedInputFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21785,7 +21607,8 @@ + (void)readAttributeWiredAssessedInputFrequencyWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
@@ -21794,9 +21617,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21806,14 +21628,15 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeWiredCurrentTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterWiredCurrentTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
-            auto successFn = Callback<PowerSourceClusterWiredCurrentTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredCurrentTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21822,27 +21645,27 @@ - (void)subscribeAttributeWiredCurrentTypeWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
-                auto successFn = Callback<PowerSourceClusterWiredCurrentTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterWiredCurrentTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredCurrentTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21850,8 +21673,9 @@ + (void)readAttributeWiredCurrentTypeWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceClusterWiredCurrentTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
@@ -21860,9 +21684,8 @@ new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceClusterWiredCurrentTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -21872,14 +21695,14 @@ new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(
 
 - (void)readAttributeWiredAssessedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredAssessedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21889,27 +21712,25 @@ - (void)subscribeAttributeWiredAssessedCurrentWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredAssessedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21918,7 +21739,8 @@ + (void)readAttributeWiredAssessedCurrentWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
@@ -21927,9 +21749,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -21939,14 +21760,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeWiredNominalVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredNominalVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -21956,26 +21777,25 @@ - (void)subscribeAttributeWiredNominalVoltageWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredNominalVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -21984,7 +21804,8 @@ + (void)readAttributeWiredNominalVoltageWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
@@ -21993,9 +21814,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22005,14 +21825,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeWiredMaximumCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredMaximumCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22022,26 +21842,25 @@ - (void)subscribeAttributeWiredMaximumCurrentWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredMaximumCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22050,7 +21869,8 @@ + (void)readAttributeWiredMaximumCurrentWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
@@ -22059,9 +21879,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22071,14 +21890,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeWiredPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiredPresentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22087,26 +21906,25 @@ - (void)subscribeAttributeWiredPresentWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiredPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22114,7 +21932,8 @@ + (void)readAttributeWiredPresentWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
@@ -22123,9 +21942,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22135,14 +21953,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActiveWiredFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceActiveWiredFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
-            auto successFn = Callback<PowerSourceActiveWiredFaultsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveWiredFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22151,27 +21970,27 @@ - (void)subscribeAttributeActiveWiredFaultsWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
-                auto successFn = Callback<PowerSourceActiveWiredFaultsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceActiveWiredFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveWiredFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22179,8 +21998,9 @@ + (void)readAttributeActiveWiredFaultsWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceActiveWiredFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
@@ -22189,9 +22009,8 @@ new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceActiveWiredFaultsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -22201,14 +22020,14 @@ new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(
 
 - (void)readAttributeBatVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22217,27 +22036,25 @@ - (void)subscribeAttributeBatVoltageWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22245,7 +22062,8 @@ + (void)readAttributeBatVoltageWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
@@ -22254,9 +22072,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22266,14 +22083,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeBatPercentRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatPercentRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22283,27 +22100,25 @@ - (void)subscribeAttributeBatPercentRemainingWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatPercentRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22312,7 +22127,8 @@ + (void)readAttributeBatPercentRemainingWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
@@ -22321,9 +22137,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22333,14 +22148,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeBatTimeRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatTimeRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22349,27 +22164,25 @@ - (void)subscribeAttributeBatTimeRemainingWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatTimeRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22377,7 +22190,8 @@ + (void)readAttributeBatTimeRemainingWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
@@ -22386,9 +22200,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22398,14 +22211,15 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeBatChargeLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterBatChargeLevelAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
-            auto successFn = Callback<PowerSourceClusterBatChargeLevelAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatChargeLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22414,27 +22228,27 @@ - (void)subscribeAttributeBatChargeLevelWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
-                auto successFn = Callback<PowerSourceClusterBatChargeLevelAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterBatChargeLevelAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatChargeLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22442,8 +22256,9 @@ + (void)readAttributeBatChargeLevelWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceClusterBatChargeLevelAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
@@ -22452,9 +22267,8 @@ new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceClusterBatChargeLevelAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -22464,14 +22278,14 @@ new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(
 
 - (void)readAttributeBatReplacementNeededWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatReplacementNeededWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22481,26 +22295,25 @@ - (void)subscribeAttributeBatReplacementNeededWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatReplacementNeededWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22509,7 +22322,8 @@ + (void)readAttributeBatReplacementNeededWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
@@ -22518,9 +22332,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22530,14 +22343,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBatReplaceabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterBatReplaceabilityAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
-            auto successFn = Callback<PowerSourceClusterBatReplaceabilityAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatReplaceabilityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22546,27 +22360,27 @@ - (void)subscribeAttributeBatReplaceabilityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
-                auto successFn = Callback<PowerSourceClusterBatReplaceabilityAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterBatReplaceabilityAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatReplaceabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22574,8 +22388,9 @@ + (void)readAttributeBatReplaceabilityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceClusterBatReplaceabilityAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
@@ -22584,9 +22399,8 @@ new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceClusterBatReplaceabilityAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -22596,14 +22410,14 @@ new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(
 
 - (void)readAttributeBatPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatPresentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22612,26 +22426,25 @@ - (void)subscribeAttributeBatPresentWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22639,7 +22452,8 @@ + (void)readAttributeBatPresentWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
@@ -22648,9 +22462,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22660,14 +22473,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActiveBatFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceActiveBatFaultsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
-            auto successFn = Callback<PowerSourceActiveBatFaultsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveBatFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22676,27 +22489,26 @@ - (void)subscribeAttributeActiveBatFaultsWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
-                auto successFn = Callback<PowerSourceActiveBatFaultsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceActiveBatFaultsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveBatFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22704,36 +22516,37 @@ + (void)readAttributeActiveBatFaultsWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<PowerSourceActiveBatFaultsListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceActiveBatFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeBatReplacementDescriptionWithCompletion:(void (^)(
                                                                  NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatReplacementDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22743,27 +22556,25 @@ - (void)subscribeAttributeBatReplacementDescriptionWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatReplacementDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22772,7 +22583,8 @@ + (void)readAttributeBatReplacementDescriptionWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSString * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
@@ -22781,9 +22593,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22793,14 +22604,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeBatCommonDesignationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatCommonDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22810,26 +22621,25 @@ - (void)subscribeAttributeBatCommonDesignationWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatCommonDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22838,7 +22648,8 @@ + (void)readAttributeBatCommonDesignationWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
@@ -22847,9 +22658,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22859,14 +22669,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBatANSIDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatANSIDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22876,27 +22686,25 @@ - (void)subscribeAttributeBatANSIDesignationWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatANSIDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22905,7 +22713,8 @@ + (void)readAttributeBatANSIDesignationWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
@@ -22914,9 +22723,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22926,14 +22734,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeBatIECDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatIECDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -22942,27 +22750,25 @@ - (void)subscribeAttributeBatIECDesignationWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatIECDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -22970,7 +22776,8 @@ + (void)readAttributeBatIECDesignationWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
@@ -22979,9 +22786,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -22991,14 +22797,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeBatApprovedChemistryWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatApprovedChemistryWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23008,26 +22814,25 @@ - (void)subscribeAttributeBatApprovedChemistryWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatApprovedChemistryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23036,7 +22841,8 @@ + (void)readAttributeBatApprovedChemistryWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
@@ -23045,9 +22851,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23057,14 +22862,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBatCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23073,26 +22878,25 @@ - (void)subscribeAttributeBatCapacityWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23100,7 +22904,8 @@ + (void)readAttributeBatCapacityWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
@@ -23109,9 +22914,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23121,14 +22925,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBatQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatQuantityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23137,26 +22941,25 @@ - (void)subscribeAttributeBatQuantityWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23164,7 +22967,8 @@ + (void)readAttributeBatQuantityWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
@@ -23173,9 +22977,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23185,14 +22988,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeBatChargeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterBatChargeStateAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
-            auto successFn = Callback<PowerSourceClusterBatChargeStateAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatChargeStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23201,27 +23005,27 @@ - (void)subscribeAttributeBatChargeStateWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
-                auto successFn = Callback<PowerSourceClusterBatChargeStateAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceClusterBatChargeStateAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatChargeStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23229,8 +23033,9 @@ + (void)readAttributeBatChargeStateWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceClusterBatChargeStateAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
@@ -23239,9 +23044,8 @@ new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceClusterBatChargeStateAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -23251,14 +23055,14 @@ new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(
 
 - (void)readAttributeBatTimeToFullChargeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatTimeToFullChargeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23268,27 +23072,25 @@ - (void)subscribeAttributeBatTimeToFullChargeWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatTimeToFullChargeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23297,7 +23099,8 @@ + (void)readAttributeBatTimeToFullChargeWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
@@ -23306,9 +23109,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23319,14 +23121,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeBatFunctionalWhileChargingWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatFunctionalWhileChargingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23336,26 +23138,25 @@ - (void)subscribeAttributeBatFunctionalWhileChargingWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatFunctionalWhileChargingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23364,7 +23165,8 @@ + (void)readAttributeBatFunctionalWhileChargingWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
@@ -23373,9 +23175,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23385,14 +23186,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBatChargingCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBatChargingCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23402,27 +23203,25 @@ - (void)subscribeAttributeBatChargingCurrentWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBatChargingCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23431,7 +23230,8 @@ + (void)readAttributeBatChargingCurrentWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
@@ -23440,9 +23240,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23452,14 +23251,15 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeActiveBatChargeFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceActiveBatChargeFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
-            auto successFn = Callback<PowerSourceActiveBatChargeFaultsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveBatChargeFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23469,27 +23269,27 @@ - (void)subscribeAttributeActiveBatChargeFaultsWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
-                auto successFn = Callback<PowerSourceActiveBatChargeFaultsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceActiveBatChargeFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveBatChargeFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23498,8 +23298,9 @@ + (void)readAttributeActiveBatChargeFaultsWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceActiveBatChargeFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
@@ -23508,9 +23309,8 @@ new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceActiveBatChargeFaultsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -23520,14 +23320,15 @@ new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<PowerSourceGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23537,27 +23338,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<PowerSourceGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23566,8 +23367,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
@@ -23576,9 +23378,8 @@ new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -23588,14 +23389,15 @@ new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<PowerSourceAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23605,27 +23407,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<PowerSourceAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PowerSourceAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23634,8 +23436,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PowerSourceAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
@@ -23644,9 +23447,8 @@ new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PowerSourceAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -23656,14 +23458,14 @@ new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, PowerSourceAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<PowerSourceAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23672,27 +23474,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<PowerSourceAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, PowerSourceAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23700,7 +23501,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(PowerSourceAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
@@ -23709,9 +23511,8 @@ new MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<PowerSourceAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23721,14 +23522,14 @@ new MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23737,26 +23538,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23764,7 +23564,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
@@ -23773,9 +23574,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -23785,14 +23585,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -23801,26 +23601,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -23828,7 +23627,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
@@ -23837,9 +23637,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -25135,8 +24934,10 @@ - (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterArmFailSafeResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GeneralCommissioning::Commands::ArmFailSafe::Type request;
@@ -25148,11 +24949,10 @@ new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbac
             request.expiryLengthSeconds = params.expiryLengthSeconds.unsignedShortValue;
             request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
 
-            auto successFn = Callback<GeneralCommissioningClusterArmFailSafeResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params
@@ -25161,8 +24961,10 @@ - (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulato
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GeneralCommissioning::Commands::SetRegulatoryConfig::Type request;
@@ -25176,11 +24978,10 @@ new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self
             request.countryCode = [self asCharSpan:params.countryCode];
             request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
 
-            auto successFn = Callback<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)commissioningCompleteWithCompletion:(void (^)(
@@ -25196,8 +24997,10 @@ - (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissio
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterCommissioningCompleteResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GeneralCommissioning::Commands::CommissioningComplete::Type request;
@@ -25207,24 +25010,22 @@ new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(se
                 }
             }
 
-            auto successFn
-                = Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeBreadcrumbWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -25239,12 +25040,13 @@ - (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -25256,13 +25058,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedLongLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBreadcrumbWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25271,26 +25071,25 @@ - (void)subscribeAttributeBreadcrumbWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBreadcrumbWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25298,7 +25097,8 @@ + (void)readAttributeBreadcrumbWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
@@ -25307,9 +25107,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -25320,14 +25119,15 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeBasicCommissioningInfoWithCompletion:
     (void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningBasicCommissioningInfoStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
-            auto successFn = Callback<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBasicCommissioningInfoWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25338,30 +25138,28 @@ - (void)subscribeAttributeBasicCommissioningInfoWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
-                auto successFn
-                    = Callback<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningBasicCommissioningInfoStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
+
+            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBasicCommissioningInfoWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25372,8 +25170,9 @@ + (void)readAttributeBasicCommissioningInfoWithAttributeCache:(MTRAttributeCache
                                                            MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value,
                                                            NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralCommissioningBasicCommissioningInfoStructAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
@@ -25382,10 +25181,8 @@ new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -25395,14 +25192,15 @@ new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(
 
 - (void)readAttributeRegulatoryConfigWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
-            auto successFn = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRegulatoryConfigWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25411,30 +25209,28 @@ - (void)subscribeAttributeRegulatoryConfigWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
-                auto successFn
-                    = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
+
+            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRegulatoryConfigWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25442,8 +25238,9 @@ + (void)readAttributeRegulatoryConfigWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
@@ -25452,10 +25249,8 @@ new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -25465,14 +25260,15 @@ new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
 
 - (void)readAttributeLocationCapabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
-            auto successFn = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLocationCapabilityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25482,30 +25278,28 @@ - (void)subscribeAttributeLocationCapabilityWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
-                auto successFn
-                    = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
+
+            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLocationCapabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25514,8 +25308,9 @@ + (void)readAttributeLocationCapabilityWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
@@ -25524,10 +25319,8 @@ new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -25538,14 +25331,14 @@ new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
 - (void)readAttributeSupportsConcurrentConnectionWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportsConcurrentConnectionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25556,26 +25349,25 @@ - (void)subscribeAttributeSupportsConcurrentConnectionWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportsConcurrentConnectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25584,7 +25376,8 @@ + (void)readAttributeSupportsConcurrentConnectionWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
@@ -25593,9 +25386,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -25605,14 +25397,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<GeneralCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25622,28 +25415,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<GeneralCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25652,8 +25445,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
@@ -25662,9 +25456,8 @@ new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -25674,14 +25467,15 @@ new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<GeneralCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25691,28 +25485,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<GeneralCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25721,8 +25515,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
@@ -25731,9 +25526,8 @@ new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -25743,14 +25537,15 @@ new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<GeneralCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25759,27 +25554,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<GeneralCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25787,8 +25582,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
@@ -25797,9 +25593,8 @@ new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -25809,14 +25604,14 @@ new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25825,26 +25620,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25852,7 +25646,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
@@ -25861,9 +25656,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -25873,14 +25667,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -25889,26 +25683,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -25916,7 +25709,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
@@ -25925,9 +25719,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -26356,8 +26149,10 @@ - (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningClusterScanNetworksResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             NetworkCommissioning::Commands::ScanNetworks::Type request;
@@ -26382,11 +26177,10 @@ new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callba
                 }
             }
 
-            auto successFn = Callback<NetworkCommissioningClusterScanNetworksResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params
@@ -26395,8 +26189,10 @@ - (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpd
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type request;
@@ -26412,11 +26208,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                 definedValue_0 = params.breadcrumb.unsignedLongLongValue;
             }
 
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params
@@ -26425,8 +26220,10 @@ - (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrU
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type request;
@@ -26441,11 +26238,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                 definedValue_0 = params.breadcrumb.unsignedLongLongValue;
             }
 
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params
@@ -26454,8 +26250,10 @@ - (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             NetworkCommissioning::Commands::RemoveNetwork::Type request;
@@ -26470,11 +26268,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                 definedValue_0 = params.breadcrumb.unsignedLongLongValue;
             }
 
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params
@@ -26483,8 +26280,10 @@ - (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningClusterConnectNetworkResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             NetworkCommissioning::Commands::ConnectNetwork::Type request;
@@ -26499,11 +26298,10 @@ new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.call
                 definedValue_0 = params.breadcrumb.unsignedLongLongValue;
             }
 
-            auto successFn = Callback<NetworkCommissioningClusterConnectNetworkResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params
@@ -26512,8 +26310,10 @@ - (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             NetworkCommissioning::Commands::ReorderNetwork::Type request;
@@ -26529,23 +26329,22 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                 definedValue_0 = params.breadcrumb.unsignedLongLongValue;
             }
 
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeMaxNetworksWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxNetworksWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26554,26 +26353,25 @@ - (void)subscribeAttributeMaxNetworksWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -26581,7 +26379,8 @@ + (void)readAttributeMaxNetworksWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
@@ -26590,9 +26389,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -26602,14 +26400,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeNetworksWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningNetworksListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
-            auto successFn = Callback<NetworkCommissioningNetworksListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNetworksWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26618,27 +26417,27 @@ - (void)subscribeAttributeNetworksWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
-                auto successFn = Callback<NetworkCommissioningNetworksListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningNetworksListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
 
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -26646,8 +26445,9 @@ + (void)readAttributeNetworksWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NetworkCommissioningNetworksListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
@@ -26656,9 +26456,8 @@ new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NetworkCommissioningNetworksListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -26668,14 +26467,14 @@ new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(
 
 - (void)readAttributeScanMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeScanMaxTimeSecondsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26685,26 +26484,25 @@ - (void)subscribeAttributeScanMaxTimeSecondsWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeScanMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -26713,7 +26511,8 @@ + (void)readAttributeScanMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
@@ -26722,9 +26521,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -26734,14 +26532,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeConnectMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeConnectMaxTimeSecondsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26751,26 +26549,25 @@ - (void)subscribeAttributeConnectMaxTimeSecondsWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeConnectMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -26779,7 +26576,8 @@ + (void)readAttributeConnectMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
@@ -26788,9 +26586,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -26800,14 +26597,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeInterfaceEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -26822,12 +26619,13 @@ - (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -26839,13 +26637,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInterfaceEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26854,26 +26650,25 @@ - (void)subscribeAttributeInterfaceEnabledWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInterfaceEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -26881,7 +26676,8 @@ + (void)readAttributeInterfaceEnabledWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
@@ -26890,9 +26686,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -26902,16 +26697,16 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeLastNetworkingStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(self.callbackQueue, self.device,
+    auto * bridge = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(self.callbackQueue,
         completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
-            auto successFn
-                = Callback<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLastNetworkingStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26921,32 +26716,29 @@ - (void)subscribeAttributeLastNetworkingStatusWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
-                auto successFn
-                    = Callback<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>::FromCancelable(
-                        success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge *
-                    innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<
+                MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
+
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLastNetworkingStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -26955,8 +26747,9 @@ + (void)readAttributeLastNetworkingStatusWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
@@ -26965,11 +26758,8 @@ new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCal
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>::FromCancelable(
-                        success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -26979,14 +26769,14 @@ new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCal
 
 - (void)readAttributeLastNetworkIDWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLastNetworkIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -26995,27 +26785,25 @@ - (void)subscribeAttributeLastNetworkIDWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableOctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
-                auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
 
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableOctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLastNetworkIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27023,7 +26811,8 @@ + (void)readAttributeLastNetworkIDWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
@@ -27032,9 +26821,8 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -27044,14 +26832,14 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeLastConnectErrorValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
-            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLastConnectErrorValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -27061,27 +26849,25 @@ - (void)subscribeAttributeLastConnectErrorValueWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
-                auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
 
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLastConnectErrorValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27090,7 +26876,8 @@ + (void)readAttributeLastConnectErrorValueWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
@@ -27099,9 +26886,8 @@ new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -27111,14 +26897,15 @@ new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<NetworkCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -27128,28 +26915,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<NetworkCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27158,8 +26945,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NetworkCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
@@ -27168,9 +26956,8 @@ new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NetworkCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -27180,14 +26967,15 @@ new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<NetworkCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -27197,28 +26985,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<NetworkCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27227,8 +27015,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NetworkCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
@@ -27237,9 +27026,8 @@ new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NetworkCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -27249,14 +27037,15 @@ new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<NetworkCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -27265,27 +27054,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<NetworkCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NetworkCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27293,8 +27082,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NetworkCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
@@ -27303,9 +27093,8 @@ new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NetworkCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -27315,14 +27104,14 @@ new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -27331,26 +27120,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27358,7 +27146,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
@@ -27367,9 +27156,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -27379,14 +27167,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -27395,26 +27183,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -27422,7 +27209,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
@@ -27431,9 +27219,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -27973,8 +27760,10 @@ - (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsReque
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsClusterRetrieveLogsResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DiagnosticLogs::Commands::RetrieveLogsRequest::Type request;
@@ -27988,23 +27777,23 @@ new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueu
                 params.requestedProtocol.unsignedCharValue);
             request.transferFileDesignator = [self asByteSpan:params.transferFileDesignator];
 
-            auto successFn = Callback<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<DiagnosticLogsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28014,27 +27803,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<DiagnosticLogsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28043,8 +27833,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DiagnosticLogsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
@@ -28053,9 +27844,8 @@ new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DiagnosticLogsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -28065,14 +27855,15 @@ new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<DiagnosticLogsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28082,27 +27873,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<DiagnosticLogsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28111,8 +27902,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DiagnosticLogsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
@@ -28121,9 +27913,8 @@ new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DiagnosticLogsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -28133,14 +27924,15 @@ new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<DiagnosticLogsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28149,27 +27941,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<DiagnosticLogsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DiagnosticLogsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28177,35 +27969,36 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DiagnosticLogsAttributeListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DiagnosticLogsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28214,26 +28007,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28241,7 +28033,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
@@ -28250,9 +28043,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -28262,14 +28054,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28278,26 +28070,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28305,7 +28096,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
@@ -28314,9 +28106,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -28536,12 +28327,13 @@ - (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTrigger
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GeneralDiagnostics::Commands::TestEventTrigger::Type request;
@@ -28553,23 +28345,23 @@ new MTRCommandSuccessCallbackBridge(
             request.enableKey = [self asByteSpan:params.enableKey];
             request.eventTrigger = params.eventTrigger.unsignedLongLongValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeNetworkInterfacesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsNetworkInterfacesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNetworkInterfacesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28578,28 +28370,28 @@ - (void)subscribeAttributeNetworkInterfacesWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsNetworkInterfacesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNetworkInterfacesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28607,8 +28399,9 @@ + (void)readAttributeNetworkInterfacesWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsNetworkInterfacesListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
@@ -28617,9 +28410,8 @@ new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -28629,14 +28421,14 @@ new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(
 
 - (void)readAttributeRebootCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRebootCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28645,26 +28437,25 @@ - (void)subscribeAttributeRebootCountWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRebootCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28672,7 +28463,8 @@ + (void)readAttributeRebootCountWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
@@ -28681,9 +28473,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -28693,14 +28484,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeUpTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUpTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28709,26 +28500,25 @@ - (void)subscribeAttributeUpTimeWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUpTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28736,7 +28526,8 @@ + (void)readAttributeUpTimeWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
@@ -28745,9 +28536,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -28757,14 +28547,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTotalOperationalHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTotalOperationalHoursWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28774,26 +28564,25 @@ - (void)subscribeAttributeTotalOperationalHoursWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTotalOperationalHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28802,7 +28591,8 @@ + (void)readAttributeTotalOperationalHoursWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
@@ -28811,9 +28601,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -28823,14 +28612,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBootReasonsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBootReasonsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28839,26 +28628,25 @@ - (void)subscribeAttributeBootReasonsWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBootReasonsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28866,7 +28654,8 @@ + (void)readAttributeBootReasonsWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
@@ -28875,9 +28664,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -28887,14 +28675,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeActiveHardwareFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveHardwareFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28904,28 +28693,28 @@ - (void)subscribeAttributeActiveHardwareFaultsWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveHardwareFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -28934,8 +28723,9 @@ + (void)readAttributeActiveHardwareFaultsWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
@@ -28944,9 +28734,8 @@ new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -28956,14 +28745,15 @@ new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(
 
 - (void)readAttributeActiveRadioFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsActiveRadioFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveRadioFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -28972,28 +28762,28 @@ - (void)subscribeAttributeActiveRadioFaultsWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsActiveRadioFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveRadioFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29001,8 +28791,9 @@ + (void)readAttributeActiveRadioFaultsWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsActiveRadioFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
@@ -29011,9 +28802,8 @@ new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -29023,14 +28813,15 @@ new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(
 
 - (void)readAttributeActiveNetworkFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveNetworkFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29040,28 +28831,28 @@ - (void)subscribeAttributeActiveNetworkFaultsWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveNetworkFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29070,8 +28861,9 @@ + (void)readAttributeActiveNetworkFaultsWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
@@ -29080,9 +28872,8 @@ new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -29093,14 +28884,14 @@ new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(
 - (void)readAttributeTestEventTriggersEnabledWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTestEventTriggersEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29110,26 +28901,25 @@ - (void)subscribeAttributeTestEventTriggersEnabledWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTestEventTriggersEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29138,7 +28928,8 @@ + (void)readAttributeTestEventTriggersEnabledWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
@@ -29147,9 +28938,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -29159,14 +28949,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29176,28 +28967,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29206,8 +28997,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
@@ -29216,9 +29008,8 @@ new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -29228,14 +29019,15 @@ new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29245,28 +29037,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29275,8 +29067,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
@@ -29285,9 +29078,8 @@ new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -29297,14 +29089,15 @@ new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<GeneralDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29313,27 +29106,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<GeneralDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GeneralDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29341,8 +29134,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GeneralDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
@@ -29351,9 +29145,8 @@ new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GeneralDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -29363,14 +29156,14 @@ new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29379,26 +29172,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29406,7 +29198,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
@@ -29415,9 +29208,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -29427,14 +29219,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -29443,26 +29235,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -29470,7 +29261,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
@@ -29479,9 +29271,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -30015,12 +29806,13 @@ - (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             SoftwareDiagnostics::Commands::ResetWatermarks::Type request;
@@ -30030,23 +29822,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeThreadMetricsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsThreadMetricsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
-            auto successFn = Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeThreadMetricsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30055,27 +29847,27 @@ - (void)subscribeAttributeThreadMetricsWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
-                auto successFn = Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsThreadMetricsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
 
-                chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeThreadMetricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30083,8 +29875,9 @@ + (void)readAttributeThreadMetricsWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(SoftwareDiagnosticsThreadMetricsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
@@ -30093,9 +29886,8 @@ new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<SoftwareDiagnosticsThreadMetricsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -30105,14 +29897,14 @@ new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(
 
 - (void)readAttributeCurrentHeapFreeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentHeapFreeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30121,26 +29913,25 @@ - (void)subscribeAttributeCurrentHeapFreeWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentHeapFreeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30148,7 +29939,8 @@ + (void)readAttributeCurrentHeapFreeWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
@@ -30157,9 +29949,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -30169,14 +29960,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCurrentHeapUsedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentHeapUsedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30185,26 +29976,25 @@ - (void)subscribeAttributeCurrentHeapUsedWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentHeapUsedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30212,7 +30002,8 @@ + (void)readAttributeCurrentHeapUsedWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
@@ -30221,9 +30012,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -30234,14 +30024,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeCurrentHeapHighWatermarkWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentHeapHighWatermarkWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30251,26 +30041,25 @@ - (void)subscribeAttributeCurrentHeapHighWatermarkWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentHeapHighWatermarkWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30279,7 +30068,8 @@ + (void)readAttributeCurrentHeapHighWatermarkWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
@@ -30288,9 +30078,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -30300,14 +30089,15 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30317,28 +30107,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30347,8 +30137,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(SoftwareDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
@@ -30357,9 +30148,8 @@ new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -30369,14 +30159,15 @@ new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30386,28 +30177,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30416,8 +30207,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(SoftwareDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
@@ -30426,9 +30218,8 @@ new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -30438,14 +30229,15 @@ new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<SoftwareDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30454,27 +30246,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<SoftwareDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SoftwareDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30482,8 +30274,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(SoftwareDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
@@ -30492,9 +30285,8 @@ new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<SoftwareDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -30504,14 +30296,14 @@ new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30520,26 +30312,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30547,7 +30338,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
@@ -30556,9 +30348,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -30568,14 +30359,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -30584,26 +30375,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -30611,7 +30401,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
@@ -30620,9 +30411,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -30989,12 +30779,13 @@ - (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ThreadNetworkDiagnostics::Commands::ResetCounts::Type request;
@@ -31004,23 +30795,22 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeChannelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeChannelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31029,27 +30819,25 @@ - (void)subscribeAttributeChannelWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31057,7 +30845,8 @@ + (void)readAttributeChannelWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
@@ -31066,9 +30855,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31078,14 +30866,15 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeRoutingRoleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
-            auto successFn = Callback<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRoutingRoleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31094,30 +30883,28 @@ - (void)subscribeAttributeRoutingRoleWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
-                auto successFn
-                    = Callback<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRoutingRoleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31125,8 +30912,9 @@ + (void)readAttributeRoutingRoleWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
@@ -31135,10 +30923,8 @@ new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -31148,14 +30934,14 @@ new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
 
 - (void)readAttributeNetworkNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
-            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNetworkNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31164,27 +30950,25 @@ - (void)subscribeAttributeNetworkNameWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
-                auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNetworkNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31192,7 +30976,8 @@ + (void)readAttributeNetworkNameWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableCharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
@@ -31201,9 +30986,8 @@ new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31213,14 +30997,14 @@ new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable
 
 - (void)readAttributePanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePanIdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31229,27 +31013,25 @@ - (void)subscribeAttributePanIdWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31257,7 +31039,8 @@ + (void)readAttributePanIdWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
@@ -31266,9 +31049,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31278,14 +31060,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeExtendedPanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeExtendedPanIdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31294,27 +31076,25 @@ - (void)subscribeAttributeExtendedPanIdWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeExtendedPanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31322,7 +31102,8 @@ + (void)readAttributeExtendedPanIdWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
@@ -31331,9 +31112,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31343,14 +31123,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMeshLocalPrefixWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeshLocalPrefixWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31359,27 +31139,25 @@ - (void)subscribeAttributeMeshLocalPrefixWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableOctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
-                auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableOctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeshLocalPrefixWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31387,7 +31165,8 @@ + (void)readAttributeMeshLocalPrefixWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
@@ -31396,9 +31175,8 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31408,14 +31186,14 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31424,26 +31202,25 @@ - (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31451,7 +31228,8 @@ + (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
@@ -31460,9 +31238,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31472,14 +31249,15 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeNeighborTableListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
-            auto successFn = Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNeighborTableListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31488,28 +31266,28 @@ - (void)subscribeAttributeNeighborTableListWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
-                auto successFn = Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNeighborTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31517,8 +31295,9 @@ + (void)readAttributeNeighborTableListWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
@@ -31527,9 +31306,8 @@ new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -31539,14 +31317,15 @@ new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(
 
 - (void)readAttributeRouteTableListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsRouteTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
-            auto successFn = Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRouteTableListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31555,28 +31334,28 @@ - (void)subscribeAttributeRouteTableListWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
-                auto successFn = Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsRouteTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRouteTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31584,8 +31363,9 @@ + (void)readAttributeRouteTableListWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsRouteTableListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
@@ -31594,9 +31374,8 @@ new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -31606,14 +31385,14 @@ new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(
 
 - (void)readAttributePartitionIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePartitionIdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31622,27 +31401,25 @@ - (void)subscribeAttributePartitionIdWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePartitionIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31650,7 +31427,8 @@ + (void)readAttributePartitionIdWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
@@ -31659,9 +31437,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31671,14 +31448,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeWeightingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWeightingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31687,27 +31464,25 @@ - (void)subscribeAttributeWeightingWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWeightingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31715,7 +31490,8 @@ + (void)readAttributeWeightingWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
@@ -31724,9 +31500,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31736,14 +31511,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDataVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31752,27 +31527,25 @@ - (void)subscribeAttributeDataVersionWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31780,7 +31553,8 @@ + (void)readAttributeDataVersionWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
@@ -31789,9 +31563,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31801,14 +31574,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeStableDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStableDataVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31817,27 +31590,25 @@ - (void)subscribeAttributeStableDataVersionWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStableDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31845,7 +31616,8 @@ + (void)readAttributeStableDataVersionWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
@@ -31854,9 +31626,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31866,14 +31637,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeLeaderRouterIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLeaderRouterIdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31882,27 +31653,25 @@ - (void)subscribeAttributeLeaderRouterIdWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLeaderRouterIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31910,7 +31679,8 @@ + (void)readAttributeLeaderRouterIdWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
@@ -31919,9 +31689,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31931,14 +31700,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeDetachedRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDetachedRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -31947,26 +31716,25 @@ - (void)subscribeAttributeDetachedRoleCountWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDetachedRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -31974,7 +31742,8 @@ + (void)readAttributeDetachedRoleCountWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
@@ -31983,9 +31752,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -31995,14 +31763,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeChildRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeChildRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32011,26 +31779,25 @@ - (void)subscribeAttributeChildRoleCountWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeChildRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32038,7 +31805,8 @@ + (void)readAttributeChildRoleCountWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
@@ -32047,9 +31815,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32059,14 +31826,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRouterRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRouterRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32075,26 +31842,25 @@ - (void)subscribeAttributeRouterRoleCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRouterRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32102,7 +31868,8 @@ + (void)readAttributeRouterRoleCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
@@ -32111,9 +31878,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32123,14 +31889,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeLeaderRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLeaderRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32139,26 +31905,25 @@ - (void)subscribeAttributeLeaderRoleCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLeaderRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32166,7 +31931,8 @@ + (void)readAttributeLeaderRoleCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
@@ -32175,9 +31941,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32187,14 +31952,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttachAttemptCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32204,26 +31969,25 @@ - (void)subscribeAttributeAttachAttemptCountWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32232,7 +31996,8 @@ + (void)readAttributeAttachAttemptCountWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
@@ -32241,9 +32006,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32254,14 +32018,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributePartitionIdChangeCountWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePartitionIdChangeCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32271,26 +32035,25 @@ - (void)subscribeAttributePartitionIdChangeCountWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePartitionIdChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32299,7 +32062,8 @@ + (void)readAttributePartitionIdChangeCountWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
@@ -32308,9 +32072,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32321,14 +32084,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeBetterPartitionAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBetterPartitionAttachAttemptCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32339,26 +32102,25 @@ - (void)subscribeAttributeBetterPartitionAttachAttemptCountWithParams:(MTRSubscr
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBetterPartitionAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32367,7 +32129,8 @@ + (void)readAttributeBetterPartitionAttachAttemptCountWithAttributeCache:(MTRAtt
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
@@ -32376,9 +32139,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32388,14 +32150,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeParentChangeCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeParentChangeCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32404,26 +32166,25 @@ - (void)subscribeAttributeParentChangeCountWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeParentChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32431,7 +32192,8 @@ + (void)readAttributeParentChangeCountWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
@@ -32440,9 +32202,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32452,14 +32213,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32468,26 +32229,25 @@ - (void)subscribeAttributeTxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32495,7 +32255,8 @@ + (void)readAttributeTxTotalCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
@@ -32504,9 +32265,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32516,14 +32276,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxUnicastCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32532,26 +32292,25 @@ - (void)subscribeAttributeTxUnicastCountWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32559,7 +32318,8 @@ + (void)readAttributeTxUnicastCountWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
@@ -32568,9 +32328,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32580,14 +32339,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxBroadcastCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32596,26 +32355,25 @@ - (void)subscribeAttributeTxBroadcastCountWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32623,7 +32381,8 @@ + (void)readAttributeTxBroadcastCountWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
@@ -32632,9 +32391,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32644,14 +32402,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxAckRequestedCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32661,26 +32419,25 @@ - (void)subscribeAttributeTxAckRequestedCountWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32689,7 +32446,8 @@ + (void)readAttributeTxAckRequestedCountWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
@@ -32698,9 +32456,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32710,14 +32467,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxAckedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxAckedCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32726,26 +32483,25 @@ - (void)subscribeAttributeTxAckedCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxAckedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32753,7 +32509,8 @@ + (void)readAttributeTxAckedCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
@@ -32762,9 +32519,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32774,14 +32530,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxNoAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxNoAckRequestedCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32791,26 +32547,25 @@ - (void)subscribeAttributeTxNoAckRequestedCountWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxNoAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32819,7 +32574,8 @@ + (void)readAttributeTxNoAckRequestedCountWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
@@ -32828,9 +32584,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32840,14 +32595,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxDataCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32856,26 +32611,25 @@ - (void)subscribeAttributeTxDataCountWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32883,7 +32637,8 @@ + (void)readAttributeTxDataCountWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
@@ -32892,9 +32647,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32904,14 +32658,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxDataPollCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32920,26 +32674,25 @@ - (void)subscribeAttributeTxDataPollCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -32947,7 +32700,8 @@ + (void)readAttributeTxDataPollCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
@@ -32956,9 +32710,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -32968,14 +32721,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -32984,26 +32737,25 @@ - (void)subscribeAttributeTxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33011,7 +32763,8 @@ + (void)readAttributeTxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
@@ -33020,9 +32773,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33032,14 +32784,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxBeaconRequestCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33049,26 +32801,25 @@ - (void)subscribeAttributeTxBeaconRequestCountWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33077,7 +32828,8 @@ + (void)readAttributeTxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
@@ -33086,9 +32838,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33098,14 +32849,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33114,26 +32865,25 @@ - (void)subscribeAttributeTxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33141,7 +32891,8 @@ + (void)readAttributeTxOtherCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
@@ -33150,9 +32901,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33162,14 +32912,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxRetryCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxRetryCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33178,26 +32928,25 @@ - (void)subscribeAttributeTxRetryCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxRetryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33205,7 +32954,8 @@ + (void)readAttributeTxRetryCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
@@ -33214,9 +32964,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33227,14 +32976,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33244,26 +32993,25 @@ - (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxDirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33272,7 +33020,8 @@ + (void)readAttributeTxDirectMaxRetryExpiryCountWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
@@ -33281,9 +33030,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33294,14 +33042,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33312,26 +33060,25 @@ - (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxIndirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33340,7 +33087,8 @@ + (void)readAttributeTxIndirectMaxRetryExpiryCountWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
@@ -33349,9 +33097,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33361,14 +33108,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxErrCcaCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxErrCcaCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33377,26 +33124,25 @@ - (void)subscribeAttributeTxErrCcaCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxErrCcaCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33404,7 +33150,8 @@ + (void)readAttributeTxErrCcaCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
@@ -33413,9 +33160,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33425,14 +33171,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxErrAbortCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxErrAbortCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33441,26 +33187,25 @@ - (void)subscribeAttributeTxErrAbortCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxErrAbortCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33468,7 +33213,8 @@ + (void)readAttributeTxErrAbortCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
@@ -33477,9 +33223,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33489,14 +33234,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxErrBusyChannelCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxErrBusyChannelCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33506,26 +33251,25 @@ - (void)subscribeAttributeTxErrBusyChannelCountWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxErrBusyChannelCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33534,7 +33278,8 @@ + (void)readAttributeTxErrBusyChannelCountWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
@@ -33543,9 +33288,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33555,14 +33299,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33571,26 +33315,25 @@ - (void)subscribeAttributeRxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33598,7 +33341,8 @@ + (void)readAttributeRxTotalCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
@@ -33607,9 +33351,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33619,14 +33362,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxUnicastCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33635,26 +33378,25 @@ - (void)subscribeAttributeRxUnicastCountWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33662,7 +33404,8 @@ + (void)readAttributeRxUnicastCountWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
@@ -33671,9 +33414,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33683,14 +33425,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxBroadcastCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33699,26 +33441,25 @@ - (void)subscribeAttributeRxBroadcastCountWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33726,7 +33467,8 @@ + (void)readAttributeRxBroadcastCountWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
@@ -33735,9 +33477,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33747,14 +33488,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxDataCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33763,26 +33504,25 @@ - (void)subscribeAttributeRxDataCountWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33790,7 +33530,8 @@ + (void)readAttributeRxDataCountWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
@@ -33799,9 +33540,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33811,14 +33551,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxDataPollCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33827,26 +33567,25 @@ - (void)subscribeAttributeRxDataPollCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33854,7 +33593,8 @@ + (void)readAttributeRxDataPollCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
@@ -33863,9 +33603,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33875,14 +33614,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33891,26 +33630,25 @@ - (void)subscribeAttributeRxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33918,7 +33656,8 @@ + (void)readAttributeRxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
@@ -33927,9 +33666,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -33939,14 +33677,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxBeaconRequestCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -33956,26 +33694,25 @@ - (void)subscribeAttributeRxBeaconRequestCountWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -33984,7 +33721,8 @@ + (void)readAttributeRxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
@@ -33993,9 +33731,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34005,14 +33742,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34021,26 +33758,25 @@ - (void)subscribeAttributeRxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34048,7 +33784,8 @@ + (void)readAttributeRxOtherCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
@@ -34057,9 +33794,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34070,14 +33806,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRxAddressFilteredCountWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxAddressFilteredCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34087,26 +33823,25 @@ - (void)subscribeAttributeRxAddressFilteredCountWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxAddressFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34115,7 +33850,8 @@ + (void)readAttributeRxAddressFilteredCountWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
@@ -34124,9 +33860,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34137,14 +33872,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRxDestAddrFilteredCountWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxDestAddrFilteredCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34154,26 +33889,25 @@ - (void)subscribeAttributeRxDestAddrFilteredCountWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxDestAddrFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34182,7 +33916,8 @@ + (void)readAttributeRxDestAddrFilteredCountWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
@@ -34191,9 +33926,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34203,14 +33937,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxDuplicatedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxDuplicatedCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34219,26 +33953,25 @@ - (void)subscribeAttributeRxDuplicatedCountWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxDuplicatedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34246,7 +33979,8 @@ + (void)readAttributeRxDuplicatedCountWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
@@ -34255,9 +33989,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34267,14 +34000,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxErrNoFrameCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxErrNoFrameCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34283,26 +34016,25 @@ - (void)subscribeAttributeRxErrNoFrameCountWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxErrNoFrameCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34310,7 +34042,8 @@ + (void)readAttributeRxErrNoFrameCountWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
@@ -34319,9 +34052,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34332,14 +34064,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRxErrUnknownNeighborCountWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxErrUnknownNeighborCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34349,26 +34081,25 @@ - (void)subscribeAttributeRxErrUnknownNeighborCountWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxErrUnknownNeighborCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34377,7 +34108,8 @@ + (void)readAttributeRxErrUnknownNeighborCountWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
@@ -34386,9 +34118,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34399,14 +34130,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRxErrInvalidSrcAddrCountWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxErrInvalidSrcAddrCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34416,26 +34147,25 @@ - (void)subscribeAttributeRxErrInvalidSrcAddrCountWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxErrInvalidSrcAddrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34444,7 +34174,8 @@ + (void)readAttributeRxErrInvalidSrcAddrCountWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
@@ -34453,9 +34184,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34465,14 +34195,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxErrSecCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxErrSecCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34481,26 +34211,25 @@ - (void)subscribeAttributeRxErrSecCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxErrSecCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34508,7 +34237,8 @@ + (void)readAttributeRxErrSecCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
@@ -34517,9 +34247,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34529,14 +34258,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxErrFcsCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxErrFcsCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34545,26 +34274,25 @@ - (void)subscribeAttributeRxErrFcsCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxErrFcsCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34572,7 +34300,8 @@ + (void)readAttributeRxErrFcsCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
@@ -34581,9 +34310,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34593,14 +34321,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRxErrOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRxErrOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34609,26 +34337,25 @@ - (void)subscribeAttributeRxErrOtherCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRxErrOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34636,7 +34363,8 @@ + (void)readAttributeRxErrOtherCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
@@ -34645,9 +34373,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34657,14 +34384,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActiveTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34673,27 +34400,25 @@ - (void)subscribeAttributeActiveTimestampWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34701,7 +34426,8 @@ + (void)readAttributeActiveTimestampWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
@@ -34710,9 +34436,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34722,14 +34447,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributePendingTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePendingTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34738,27 +34463,25 @@ - (void)subscribeAttributePendingTimestampWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePendingTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34766,7 +34489,8 @@ + (void)readAttributePendingTimestampWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
@@ -34775,9 +34499,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34787,14 +34510,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34803,27 +34526,25 @@ - (void)subscribeAttributeDelayWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34831,7 +34552,8 @@ + (void)readAttributeDelayWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
@@ -34840,9 +34562,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34853,14 +34574,15 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeSecurityPolicyWithCompletion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                       NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
-            auto successFn = Callback<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSecurityPolicyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34870,28 +34592,28 @@ - (void)subscribeAttributeSecurityPolicyWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
-                auto successFn = Callback<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSecurityPolicyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34900,8 +34622,9 @@ + (void)readAttributeSecurityPolicyWithAttributeCache:(MTRAttributeCacheContaine
                                            completion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                           NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
@@ -34910,9 +34633,8 @@ new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -34922,14 +34644,14 @@ new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(
 
 - (void)readAttributeChannelPage0MaskWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeChannelPage0MaskWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -34938,27 +34660,25 @@ - (void)subscribeAttributeChannelPage0MaskWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableOctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
-                auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableOctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeChannelPage0MaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -34966,7 +34686,8 @@ + (void)readAttributeChannelPage0MaskWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
@@ -34975,9 +34696,8 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -34989,16 +34709,16 @@ - (void)readAttributeOperationalDatasetComponentsWithCompletion:
     (void (^)(
         MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(self.callbackQueue, self.device,
-        completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
-            auto successFn
-                = Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
+                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)
@@ -35011,32 +34731,30 @@ new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallba
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>::FromCancelable(
-                        success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge *>(
+                    bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge *
-                    innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)
@@ -35048,8 +34766,9 @@ new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallba
                                                              MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
                                                              NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
@@ -35058,11 +34777,8 @@ new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallba
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>::FromCancelable(
-                        success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -35073,15 +34789,16 @@ new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallba
 - (void)readAttributeActiveNetworkFaultsListWithCompletion:(void (^)(
                                                                NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
-            auto successFn
-                = Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
+                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveNetworkFaultsListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -35091,30 +34808,29 @@ - (void)subscribeAttributeActiveNetworkFaultsListWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveNetworkFaultsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -35123,8 +34839,9 @@ + (void)readAttributeActiveNetworkFaultsListWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
@@ -35133,10 +34850,8 @@ new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridg
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -35146,14 +34861,15 @@ new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridg
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -35163,30 +34879,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -35195,8 +34909,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
@@ -35205,10 +34920,8 @@ new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -35218,14 +34931,15 @@ new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -35235,30 +34949,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -35267,8 +34979,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
@@ -35277,10 +34990,8 @@ new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -35290,14 +35001,15 @@ new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -35306,28 +35018,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThreadNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -35335,8 +35047,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThreadNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
@@ -35345,9 +35058,8 @@ new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -35357,14 +35069,14 @@ new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -35373,26 +35085,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -35400,7 +35111,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
@@ -35409,9 +35121,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -35421,14 +35132,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -35437,26 +35148,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -35464,7 +35174,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
@@ -35473,9 +35184,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -37906,12 +37616,13 @@ - (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WiFiNetworkDiagnostics::Commands::ResetCounts::Type request;
@@ -37921,23 +37632,22 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeBssidWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBssidWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -37946,27 +37656,25 @@ - (void)subscribeAttributeBssidWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableOctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
-                auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableOctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBssidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -37974,7 +37682,8 @@ + (void)readAttributeBssidWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
@@ -37983,9 +37692,8 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -37995,14 +37703,15 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeSecurityTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
-            auto successFn = Callback<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSecurityTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38011,30 +37720,28 @@ - (void)subscribeAttributeSecurityTypeWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
-                auto successFn
-                    = Callback<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSecurityTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38042,8 +37749,9 @@ + (void)readAttributeSecurityTypeWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
@@ -38052,10 +37760,8 @@ new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -38065,15 +37771,16 @@ new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(
 
 - (void)readAttributeWiFiVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
-            auto successFn
-                = Callback<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
+                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWiFiVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38082,30 +37789,29 @@ - (void)subscribeAttributeWiFiVersionWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
-                auto successFn
-                    = Callback<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWiFiVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38113,8 +37819,9 @@ + (void)readAttributeWiFiVersionWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
@@ -38123,10 +37830,8 @@ new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBrid
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -38136,14 +37841,14 @@ new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBrid
 
 - (void)readAttributeChannelNumberWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeChannelNumberWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38152,27 +37857,25 @@ - (void)subscribeAttributeChannelNumberWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeChannelNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38180,7 +37883,8 @@ + (void)readAttributeChannelNumberWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
@@ -38189,9 +37893,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38201,14 +37904,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeRssiWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
-            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRssiWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38217,27 +37920,25 @@ - (void)subscribeAttributeRssiWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
-                auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRssiWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38245,7 +37946,8 @@ + (void)readAttributeRssiWithAttributeCache:(MTRAttributeCacheContainer *)attrib
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
@@ -38254,9 +37956,8 @@ new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38266,14 +37967,14 @@ new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeBeaconLostCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBeaconLostCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38282,27 +37983,25 @@ - (void)subscribeAttributeBeaconLostCountWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBeaconLostCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38310,7 +38009,8 @@ + (void)readAttributeBeaconLostCountWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
@@ -38319,9 +38019,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38331,14 +38030,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeBeaconRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBeaconRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38347,27 +38046,25 @@ - (void)subscribeAttributeBeaconRxCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBeaconRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38375,7 +38072,8 @@ + (void)readAttributeBeaconRxCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
@@ -38384,9 +38082,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38397,14 +38094,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributePacketMulticastRxCountWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePacketMulticastRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38414,27 +38111,25 @@ - (void)subscribeAttributePacketMulticastRxCountWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePacketMulticastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38443,7 +38138,8 @@ + (void)readAttributePacketMulticastRxCountWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
@@ -38452,9 +38148,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38465,14 +38160,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributePacketMulticastTxCountWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePacketMulticastTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38482,27 +38177,25 @@ - (void)subscribeAttributePacketMulticastTxCountWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePacketMulticastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38511,7 +38204,8 @@ + (void)readAttributePacketMulticastTxCountWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
@@ -38520,9 +38214,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38532,14 +38225,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributePacketUnicastRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePacketUnicastRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38549,27 +38242,25 @@ - (void)subscribeAttributePacketUnicastRxCountWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePacketUnicastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38578,7 +38269,8 @@ + (void)readAttributePacketUnicastRxCountWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
@@ -38587,9 +38279,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38599,14 +38290,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributePacketUnicastTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePacketUnicastTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38616,27 +38307,25 @@ - (void)subscribeAttributePacketUnicastTxCountWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePacketUnicastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38645,7 +38334,8 @@ + (void)readAttributePacketUnicastTxCountWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
@@ -38654,9 +38344,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38666,14 +38355,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeCurrentMaxRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentMaxRateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38682,27 +38371,25 @@ - (void)subscribeAttributeCurrentMaxRateWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentMaxRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38710,7 +38397,8 @@ + (void)readAttributeCurrentMaxRateWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
@@ -38719,9 +38407,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38731,14 +38418,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38747,27 +38434,25 @@ - (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38775,7 +38460,8 @@ + (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
@@ -38784,9 +38470,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -38796,14 +38481,15 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38813,28 +38499,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38843,8 +38529,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
@@ -38853,9 +38540,8 @@ new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -38865,14 +38551,15 @@ new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38882,28 +38569,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38912,8 +38599,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
@@ -38922,9 +38610,8 @@ new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -38934,14 +38621,15 @@ new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WiFiNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -38950,28 +38638,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WiFiNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -38979,8 +38667,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WiFiNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
@@ -38989,9 +38678,8 @@ new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -39001,14 +38689,14 @@ new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -39017,26 +38705,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -39044,7 +38731,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
@@ -39053,9 +38741,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -39065,14 +38752,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -39081,26 +38768,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -39108,7 +38794,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
@@ -39117,9 +38804,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -39790,12 +39476,13 @@ - (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             EthernetNetworkDiagnostics::Commands::ResetCounts::Type request;
@@ -39805,24 +39492,24 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributePHYRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
-            auto successFn
-                = Callback<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
+                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePHYRateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -39831,30 +39518,29 @@ - (void)subscribeAttributePHYRateWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
-                auto successFn
-                    = Callback<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
 
-                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePHYRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -39862,8 +39548,9 @@ + (void)readAttributePHYRateWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
@@ -39872,10 +39559,8 @@ new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBrid
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -39885,14 +39570,14 @@ new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBrid
 
 - (void)readAttributeFullDuplexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
-            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFullDuplexWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -39901,27 +39586,25 @@ - (void)subscribeAttributeFullDuplexWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableBooleanAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
-                auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableBooleanAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
 
-                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFullDuplexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -39929,7 +39612,8 @@ + (void)readAttributeFullDuplexWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableBooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
@@ -39938,9 +39622,8 @@ new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable *
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -39950,14 +39633,14 @@ new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable *
 
 - (void)readAttributePacketRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePacketRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -39966,26 +39649,25 @@ - (void)subscribeAttributePacketRxCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePacketRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -39993,7 +39675,8 @@ + (void)readAttributePacketRxCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
@@ -40002,9 +39685,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40014,14 +39696,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePacketTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePacketTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40030,26 +39712,25 @@ - (void)subscribeAttributePacketTxCountWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePacketTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40057,7 +39738,8 @@ + (void)readAttributePacketTxCountWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
@@ -40066,9 +39748,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40078,14 +39759,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTxErrCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTxErrCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40094,26 +39775,25 @@ - (void)subscribeAttributeTxErrCountWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTxErrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40121,7 +39801,8 @@ + (void)readAttributeTxErrCountWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
@@ -40130,9 +39811,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40142,14 +39822,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCollisionCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCollisionCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40158,26 +39838,25 @@ - (void)subscribeAttributeCollisionCountWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCollisionCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40185,7 +39864,8 @@ + (void)readAttributeCollisionCountWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
@@ -40194,9 +39874,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40206,14 +39885,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40222,26 +39901,25 @@ - (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40249,7 +39927,8 @@ + (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
@@ -40258,9 +39937,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40270,14 +39948,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCarrierDetectWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
-            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCarrierDetectWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40286,27 +39964,25 @@ - (void)subscribeAttributeCarrierDetectWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableBooleanAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
-                auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableBooleanAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
 
-                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCarrierDetectWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40314,7 +39990,8 @@ + (void)readAttributeCarrierDetectWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableBooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
@@ -40323,9 +40000,8 @@ new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable *
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40335,14 +40011,14 @@ new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable *
 
 - (void)readAttributeTimeSinceResetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTimeSinceResetWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40351,26 +40027,25 @@ - (void)subscribeAttributeTimeSinceResetWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTimeSinceResetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40378,7 +40053,8 @@ + (void)readAttributeTimeSinceResetWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
@@ -40387,9 +40063,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40399,14 +40074,15 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40416,30 +40092,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40448,8 +40122,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
@@ -40458,10 +40133,8 @@ new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -40471,14 +40144,15 @@ new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40488,30 +40162,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40520,8 +40192,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
@@ -40530,10 +40203,8 @@ new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -40543,14 +40214,15 @@ new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            EthernetNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40559,28 +40231,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            EthernetNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40588,8 +40260,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(EthernetNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
@@ -40598,9 +40271,8 @@ new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -40610,14 +40282,14 @@ new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40626,26 +40298,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40653,7 +40324,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
@@ -40662,9 +40334,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -40674,14 +40345,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -40690,26 +40361,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -40717,7 +40387,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
@@ -40726,9 +40397,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41255,14 +40925,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41271,27 +40941,25 @@ - (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41299,7 +40967,8 @@ + (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
@@ -41308,9 +40977,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41320,14 +40988,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41336,26 +41004,25 @@ - (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRVendorIdAttributeCallbackSubscriptionBridge * callbackBridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRVendorIdAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41363,7 +41030,8 @@ + (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
@@ -41372,9 +41040,8 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41384,14 +41051,14 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
 
 - (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41400,27 +41067,25 @@ - (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41428,7 +41093,8 @@ + (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
@@ -41437,9 +41103,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41449,14 +41114,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -41471,12 +41136,13 @@ - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -41488,13 +41154,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNodeLabelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41503,27 +41167,25 @@ - (void)subscribeAttributeNodeLabelWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41531,7 +41193,8 @@ + (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
@@ -41540,9 +41203,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41552,14 +41214,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41568,26 +41230,25 @@ - (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41595,7 +41256,8 @@ + (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
@@ -41604,9 +41266,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41616,14 +41277,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41633,27 +41294,25 @@ - (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41662,7 +41321,8 @@ + (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
@@ -41671,9 +41331,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41683,14 +41342,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41699,26 +41358,25 @@ - (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41726,7 +41384,8 @@ + (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
@@ -41735,9 +41394,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41747,14 +41405,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41764,27 +41422,25 @@ - (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41793,7 +41449,8 @@ + (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
@@ -41802,9 +41459,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41814,14 +41470,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41830,27 +41486,25 @@ - (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41858,7 +41512,8 @@ + (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
@@ -41867,9 +41522,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41879,14 +41533,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41895,27 +41549,25 @@ - (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41923,7 +41575,8 @@ + (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
@@ -41932,9 +41585,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -41944,14 +41596,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -41960,27 +41612,25 @@ - (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -41988,7 +41638,8 @@ + (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
@@ -41997,9 +41648,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -42009,14 +41659,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42025,27 +41675,25 @@ - (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42053,7 +41701,8 @@ + (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
@@ -42062,9 +41711,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -42074,14 +41722,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42090,27 +41738,25 @@ - (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42118,7 +41764,8 @@ + (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
@@ -42127,9 +41774,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -42139,14 +41785,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42155,26 +41801,25 @@ - (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42182,7 +41827,8 @@ + (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
@@ -42191,9 +41837,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -42203,14 +41848,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42219,27 +41864,25 @@ - (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42247,7 +41890,8 @@ + (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
@@ -42256,9 +41900,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -42268,14 +41911,15 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BridgedDeviceBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42285,28 +41929,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BridgedDeviceBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42315,8 +41959,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BridgedDeviceBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
@@ -42325,9 +41970,8 @@ new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -42337,14 +41981,15 @@ new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BridgedDeviceBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42354,28 +41999,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BridgedDeviceBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42384,8 +42029,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BridgedDeviceBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
@@ -42394,9 +42040,8 @@ new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -42406,14 +42051,15 @@ new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BridgedDeviceBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BridgedDeviceBasicAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42422,27 +42068,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BridgedDeviceBasicAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BridgedDeviceBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42450,8 +42096,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BridgedDeviceBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
@@ -42460,9 +42107,8 @@ new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BridgedDeviceBasicAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -42472,14 +42118,14 @@ new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42488,26 +42134,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42515,7 +42160,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
@@ -42524,9 +42170,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -42536,14 +42181,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -42552,26 +42197,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -42579,7 +42223,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
@@ -42588,9 +42233,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43321,14 +42965,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeNumberOfPositionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfPositionsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43337,26 +42981,25 @@ - (void)subscribeAttributeNumberOfPositionsWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfPositionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43364,7 +43007,8 @@ + (void)readAttributeNumberOfPositionsWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
@@ -43373,9 +43017,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43385,14 +43028,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCurrentPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43401,26 +43044,25 @@ - (void)subscribeAttributeCurrentPositionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43428,7 +43070,8 @@ + (void)readAttributeCurrentPositionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
@@ -43437,9 +43080,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43449,14 +43091,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMultiPressMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMultiPressMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43465,26 +43107,25 @@ - (void)subscribeAttributeMultiPressMaxWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMultiPressMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43492,7 +43133,8 @@ + (void)readAttributeMultiPressMaxWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
@@ -43501,9 +43143,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43513,14 +43154,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SwitchGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<SwitchGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43530,27 +43171,26 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<SwitchGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SwitchGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43559,35 +43199,36 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<SwitchGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(SwitchGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SwitchAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<SwitchAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43597,27 +43238,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<SwitchAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            SwitchAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43626,7 +43266,8 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(SwitchAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
@@ -43635,9 +43276,8 @@ new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<SwitchAcceptedCommandListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43647,14 +43287,14 @@ new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSwitchAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSwitchAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, SwitchAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<SwitchAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43663,27 +43303,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<SwitchAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, SwitchAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43691,7 +43330,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRSwitchAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRSwitchAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(SwitchAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
@@ -43700,9 +43340,8 @@ new MTRSwitchAttributeListListAttributeCallbackBridge(queue, completion, ^(Cance
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<SwitchAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43712,14 +43351,14 @@ new MTRSwitchAttributeListListAttributeCallbackBridge(queue, completion, ^(Cance
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43728,26 +43367,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43755,7 +43393,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
@@ -43764,9 +43403,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -43776,14 +43414,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -43792,26 +43430,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -43819,7 +43456,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
@@ -43828,9 +43466,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -44149,12 +43786,13 @@ - (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterO
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AdministratorCommissioning::Commands::OpenCommissioningWindow::Type request;
@@ -44172,11 +43810,10 @@ new MTRCommandSuccessCallbackBridge(
             request.iterations = params.iterations.unsignedIntValue;
             request.salt = [self asByteSpan:params.salt];
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params
@@ -44184,12 +43821,13 @@ - (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type request;
@@ -44203,11 +43841,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.commissioningTimeout = params.commissioningTimeout.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)revokeCommissioningWithCompletion:(MTRStatusCompletion)completion
@@ -44219,12 +43856,13 @@ - (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevok
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AdministratorCommissioning::Commands::RevokeCommissioning::Type request;
@@ -44237,25 +43875,24 @@ new MTRCommandSuccessCallbackBridge(
                 timedInvokeTimeoutMs.SetValue(10000);
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeWindowStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(self.callbackQueue, self.device,
-        completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
-            auto successFn
-                = Callback<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
+                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWindowStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44264,32 +43901,30 @@ - (void)subscribeAttributeWindowStatusWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
-                auto successFn
-                    = Callback<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>::FromCancelable(
-                        success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge *>(
+                    bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
 
-                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge *
-                    innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWindowStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44297,8 +43932,9 @@ + (void)readAttributeWindowStatusWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
@@ -44307,11 +43943,8 @@ new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallba
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>::FromCancelable(
-                        success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -44321,14 +43954,14 @@ new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallba
 
 - (void)readAttributeAdminFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAdminFabricIndexWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44337,27 +43970,25 @@ - (void)subscribeAttributeAdminFabricIndexWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
 
-                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAdminFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44365,7 +43996,8 @@ + (void)readAttributeAdminFabricIndexWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
@@ -44374,9 +44006,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -44386,14 +44017,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeAdminVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAdminVendorIdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44402,27 +44033,25 @@ - (void)subscribeAttributeAdminVendorIdWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
 
-                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAdminVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44430,7 +44059,8 @@ + (void)readAttributeAdminVendorIdWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
@@ -44439,9 +44069,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -44451,14 +44080,15 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<AdministratorCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44468,30 +44098,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<AdministratorCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44500,8 +44128,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AdministratorCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
@@ -44510,10 +44139,8 @@ new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<AdministratorCommissioningGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -44523,14 +44150,15 @@ new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<AdministratorCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44540,30 +44168,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<AdministratorCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44572,8 +44198,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AdministratorCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
@@ -44582,10 +44209,8 @@ new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<AdministratorCommissioningAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -44595,14 +44220,15 @@ new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<AdministratorCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44611,28 +44237,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<AdministratorCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AdministratorCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44640,8 +44266,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AdministratorCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
@@ -44650,9 +44277,8 @@ new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AdministratorCommissioningAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -44662,14 +44288,14 @@ new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44678,26 +44304,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44705,7 +44330,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
@@ -44714,9 +44340,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -44726,14 +44351,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -44742,26 +44367,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -44769,7 +44393,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
@@ -44778,9 +44403,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -45118,8 +44742,10 @@ - (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestatio
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterAttestationResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::AttestationRequest::Type request;
@@ -45130,11 +44756,10 @@ new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callb
             }
             request.attestationNonce = [self asByteSpan:params.attestationNonce];
 
-            auto successFn = Callback<OperationalCredentialsClusterAttestationResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params
@@ -45143,8 +44768,10 @@ - (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCerti
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterCertificateChainResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::CertificateChainRequest::Type request;
@@ -45155,11 +44782,10 @@ new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.
             }
             request.certificateType = params.certificateType.unsignedCharValue;
 
-            auto successFn = Callback<OperationalCredentialsClusterCertificateChainResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params
@@ -45168,8 +44794,10 @@ - (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterCSRResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::CSRRequest::Type request;
@@ -45184,11 +44812,10 @@ new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue
                 definedValue_0 = params.isForUpdateNOC.boolValue;
             }
 
-            auto successFn = Callback<OperationalCredentialsClusterCSRResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
@@ -45197,8 +44824,10 @@ - (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::AddNOC::Type request;
@@ -45217,11 +44846,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
             request.adminVendorId
                 = static_cast<std::remove_reference_t<decltype(request.adminVendorId)>>(params.adminVendorId.unsignedShortValue);
 
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params
@@ -45230,8 +44858,10 @@ - (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::UpdateNOC::Type request;
@@ -45246,11 +44876,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
                 definedValue_0 = [self asByteSpan:params.icacValue];
             }
 
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params
@@ -45259,8 +44888,10 @@ - (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabri
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::UpdateFabricLabel::Type request;
@@ -45271,11 +44902,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
             }
             request.label = [self asCharSpan:params.label];
 
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params
@@ -45284,8 +44914,10 @@ - (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::RemoveFabric::Type request;
@@ -45296,11 +44928,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
             }
             request.fabricIndex = params.fabricIndex.unsignedCharValue;
 
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params
@@ -45308,12 +44939,13 @@ - (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAdd
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             OperationalCredentials::Commands::AddTrustedRootCertificate::Type request;
@@ -45324,26 +44956,24 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.rootCertificate = [self asByteSpan:params.rootCertificate];
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeNOCsWithParams:(MTRReadParams * _Nullable)params
                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsNOCsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsNOCsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsNOCsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
-            auto successFn = Callback<OperationalCredentialsNOCsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNOCsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45352,27 +44982,26 @@ - (void)subscribeAttributeNOCsWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
-                auto successFn = Callback<OperationalCredentialsNOCsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsNOCsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
 
-                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNOCsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45380,38 +45009,39 @@ + (void)readAttributeNOCsWithAttributeCache:(MTRAttributeCacheContainer *)attrib
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<OperationalCredentialsNOCsListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OperationalCredentialsNOCsListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeFabricsWithParams:(MTRReadParams * _Nullable)params
                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTROperationalCredentialsFabricsListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsFabricsListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsFabricsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
-            auto successFn = Callback<OperationalCredentialsFabricsListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45420,27 +45050,27 @@ - (void)subscribeAttributeFabricsWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
-                auto successFn = Callback<OperationalCredentialsFabricsListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsFabricsListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
 
-                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45448,8 +45078,9 @@ + (void)readAttributeFabricsWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsFabricsListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OperationalCredentialsFabricsListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
@@ -45458,9 +45089,8 @@ new MTROperationalCredentialsFabricsListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OperationalCredentialsFabricsListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -45470,14 +45100,14 @@ new MTROperationalCredentialsFabricsListAttributeCallbackBridge(
 
 - (void)readAttributeSupportedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportedFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45486,26 +45116,25 @@ - (void)subscribeAttributeSupportedFabricsWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45513,7 +45142,8 @@ + (void)readAttributeSupportedFabricsWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
@@ -45522,9 +45152,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -45534,14 +45163,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCommissionedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCommissionedFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45551,26 +45180,25 @@ - (void)subscribeAttributeCommissionedFabricsWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCommissionedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45579,7 +45207,8 @@ + (void)readAttributeCommissionedFabricsWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
@@ -45588,9 +45217,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -45601,14 +45229,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeTrustedRootCertificatesWithCompletion:(void (^)(
                                                                NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsTrustedRootCertificatesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
-            auto successFn = Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTrustedRootCertificatesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45618,30 +45247,28 @@ - (void)subscribeAttributeTrustedRootCertificatesWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
-                auto successFn
-                    = Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-
-                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+    auto * bridge = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsTrustedRootCertificatesListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
+
+            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTrustedRootCertificatesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45650,8 +45277,9 @@ + (void)readAttributeTrustedRootCertificatesWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OperationalCredentialsTrustedRootCertificatesListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
@@ -45660,10 +45288,8 @@ new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -45673,14 +45299,14 @@ new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(
 
 - (void)readAttributeCurrentFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentFabricIndexWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45690,26 +45316,25 @@ - (void)subscribeAttributeCurrentFabricIndexWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45718,7 +45343,8 @@ + (void)readAttributeCurrentFabricIndexWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
@@ -45727,9 +45353,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -45739,14 +45364,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<OperationalCredentialsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45756,28 +45382,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<OperationalCredentialsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45786,8 +45412,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OperationalCredentialsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
@@ -45796,9 +45423,8 @@ new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OperationalCredentialsGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -45808,14 +45434,15 @@ new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<OperationalCredentialsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45825,28 +45452,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<OperationalCredentialsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45855,8 +45482,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OperationalCredentialsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
@@ -45865,9 +45493,8 @@ new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OperationalCredentialsAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -45877,14 +45504,15 @@ new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<OperationalCredentialsAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45893,28 +45521,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<OperationalCredentialsAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OperationalCredentialsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45922,8 +45550,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OperationalCredentialsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
@@ -45932,9 +45561,8 @@ new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OperationalCredentialsAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -45944,14 +45572,14 @@ new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -45960,26 +45588,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -45987,7 +45614,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
@@ -45996,9 +45624,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -46008,14 +45635,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -46024,26 +45651,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -46051,7 +45677,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
@@ -46060,9 +45687,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -46528,12 +46154,13 @@ - (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GroupKeyManagement::Commands::KeySetWrite::Type request;
@@ -46583,11 +46210,10 @@ new MTRCommandSuccessCallbackBridge(
                 nonNullValue_1 = params.groupKeySet.epochStartTime2.unsignedLongLongValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)params
@@ -46596,8 +46222,10 @@ - (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementClusterKeySetReadResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GroupKeyManagement::Commands::KeySetRead::Type request;
@@ -46608,23 +46236,23 @@ new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQu
             }
             request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
 
-            auto successFn = Callback<GroupKeyManagementClusterKeySetReadResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GroupKeyManagement::Commands::KeySetRemove::Type request;
@@ -46635,11 +46263,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams *)params
@@ -46648,8 +46275,10 @@ - (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAl
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             GroupKeyManagement::Commands::KeySetReadAllIndices::Type request;
@@ -46681,26 +46310,25 @@ new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.
                 }
             }
 
-            auto successFn = Callback<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params
                                 completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementGroupKeyMapListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
-            auto successFn = Callback<GroupKeyManagementGroupKeyMapListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -46715,12 +46343,13 @@ - (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -46755,13 +46384,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGroupKeyMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -46770,27 +46397,27 @@ - (void)subscribeAttributeGroupKeyMapWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
-                auto successFn = Callback<GroupKeyManagementGroupKeyMapListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementGroupKeyMapListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
 
-                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGroupKeyMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -46798,8 +46425,9 @@ + (void)readAttributeGroupKeyMapWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GroupKeyManagementGroupKeyMapListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
@@ -46808,9 +46436,8 @@ new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GroupKeyManagementGroupKeyMapListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -46822,15 +46449,15 @@ - (void)readAttributeGroupTableWithParams:(MTRReadParams * _Nullable)params
                                completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementGroupTableListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
-            auto successFn = Callback<GroupKeyManagementGroupTableListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGroupTableWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -46839,27 +46466,27 @@ - (void)subscribeAttributeGroupTableWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
-                auto successFn = Callback<GroupKeyManagementGroupTableListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementGroupTableListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
 
-                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGroupTableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -46867,8 +46494,9 @@ + (void)readAttributeGroupTableWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GroupKeyManagementGroupTableListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
@@ -46877,9 +46505,8 @@ new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GroupKeyManagementGroupTableListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -46889,14 +46516,14 @@ new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(
 
 - (void)readAttributeMaxGroupsPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxGroupsPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -46906,26 +46533,25 @@ - (void)subscribeAttributeMaxGroupsPerFabricWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxGroupsPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -46934,7 +46560,8 @@ + (void)readAttributeMaxGroupsPerFabricWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
@@ -46943,9 +46570,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -46955,14 +46581,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMaxGroupKeysPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxGroupKeysPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -46972,26 +46598,25 @@ - (void)subscribeAttributeMaxGroupKeysPerFabricWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxGroupKeysPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47000,7 +46625,8 @@ + (void)readAttributeMaxGroupKeysPerFabricWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
@@ -47009,9 +46635,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -47021,14 +46646,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<GroupKeyManagementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47038,28 +46664,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<GroupKeyManagementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47068,8 +46694,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GroupKeyManagementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
@@ -47078,9 +46705,8 @@ new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GroupKeyManagementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -47090,14 +46716,15 @@ new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<GroupKeyManagementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47107,28 +46734,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<GroupKeyManagementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47137,8 +46764,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GroupKeyManagementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
@@ -47147,9 +46775,8 @@ new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GroupKeyManagementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -47159,14 +46786,15 @@ new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<GroupKeyManagementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47175,27 +46803,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<GroupKeyManagementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            GroupKeyManagementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47203,8 +46831,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(GroupKeyManagementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
@@ -47213,9 +46842,8 @@ new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<GroupKeyManagementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -47225,14 +46853,14 @@ new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47241,26 +46869,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47268,7 +46895,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
@@ -47277,9 +46905,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -47289,14 +46916,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47305,26 +46932,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47332,7 +46958,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
@@ -47341,9 +46968,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -47724,14 +47350,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelLabelListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelLabelListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelLabelListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
-            auto successFn = Callback<FixedLabelLabelListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47740,27 +47366,26 @@ - (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
-                auto successFn = Callback<FixedLabelLabelListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelLabelListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
 
-                chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47768,7 +47393,8 @@ + (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelLabelListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(FixedLabelLabelListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
@@ -47777,9 +47403,8 @@ new MTRFixedLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cance
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<FixedLabelLabelListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -47789,14 +47414,15 @@ new MTRFixedLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cance
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FixedLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<FixedLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47806,27 +47432,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<FixedLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FixedLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47835,8 +47461,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FixedLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
@@ -47845,9 +47472,8 @@ new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FixedLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -47857,14 +47483,15 @@ new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FixedLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<FixedLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47874,27 +47501,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<FixedLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FixedLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47903,8 +47530,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FixedLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
@@ -47913,9 +47541,8 @@ new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FixedLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -47925,14 +47552,14 @@ new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<FixedLabelAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -47941,27 +47568,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<FixedLabelAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -47969,7 +47595,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(FixedLabelAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
@@ -47978,9 +47605,8 @@ new MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<FixedLabelAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -47990,14 +47616,14 @@ new MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48006,26 +47632,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48033,7 +47658,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
@@ -48042,9 +47668,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -48054,14 +47679,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48070,26 +47695,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48097,7 +47721,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
@@ -48106,9 +47731,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -48351,14 +47975,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelLabelListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelLabelListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelLabelListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
-            auto successFn = Callback<UserLabelLabelListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -48373,12 +47997,13 @@ - (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -48412,13 +48037,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48427,27 +48050,25 @@ - (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
-                auto successFn = Callback<UserLabelLabelListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelLabelListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
 
-                chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48455,7 +48076,8 @@ + (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelLabelListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(UserLabelLabelListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
@@ -48464,9 +48086,8 @@ new MTRUserLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cancel
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<UserLabelLabelListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -48476,14 +48097,15 @@ new MTRUserLabelLabelListListAttributeCallbackBridge(queue, completion, ^(Cancel
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UserLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<UserLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48493,27 +48115,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<UserLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UserLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48522,8 +48144,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(UserLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
@@ -48532,9 +48155,8 @@ new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<UserLabelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -48544,14 +48166,15 @@ new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UserLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<UserLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48561,27 +48184,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<UserLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            UserLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48590,8 +48213,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(UserLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
@@ -48600,9 +48224,8 @@ new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<UserLabelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -48612,14 +48235,14 @@ new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<UserLabelAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48628,27 +48251,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<UserLabelAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48656,7 +48278,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRUserLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRUserLabelAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(UserLabelAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
@@ -48665,9 +48288,8 @@ new MTRUserLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(Ca
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<UserLabelAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -48677,14 +48299,14 @@ new MTRUserLabelAttributeListListAttributeCallbackBridge(queue, completion, ^(Ca
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48693,26 +48315,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48720,7 +48341,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
@@ -48729,9 +48351,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -48741,14 +48362,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -48757,26 +48378,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -48784,7 +48404,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
@@ -48793,9 +48414,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49048,14 +48668,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeStateValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStateValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49064,26 +48684,25 @@ - (void)subscribeAttributeStateValueWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStateValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49091,7 +48710,8 @@ + (void)readAttributeStateValueWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
@@ -49100,9 +48720,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49112,14 +48731,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BooleanStateGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BooleanStateGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49129,27 +48749,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BooleanStateGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BooleanStateGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49158,8 +48778,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BooleanStateGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
@@ -49168,9 +48789,8 @@ new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BooleanStateGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -49180,14 +48800,15 @@ new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BooleanStateAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BooleanStateAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49197,27 +48818,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BooleanStateAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BooleanStateAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49226,8 +48847,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BooleanStateAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
@@ -49236,9 +48858,8 @@ new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BooleanStateAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -49248,14 +48869,14 @@ new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanStateAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanStateAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BooleanStateAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BooleanStateAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49264,27 +48885,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BooleanStateAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BooleanStateAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49292,7 +48912,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanStateAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
@@ -49301,9 +48922,8 @@ new MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanStateAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49313,14 +48933,14 @@ new MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49329,26 +48949,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49356,7 +48975,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
@@ -49365,9 +48985,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49377,14 +48996,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49393,26 +49012,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49420,7 +49038,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
@@ -49429,9 +49048,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49676,12 +49294,13 @@ - (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ModeSelect::Commands::ChangeToMode::Type request;
@@ -49692,23 +49311,22 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.newMode = params.newMode.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49717,27 +49335,25 @@ - (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49745,7 +49361,8 @@ + (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
@@ -49754,9 +49371,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49766,14 +49382,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeStandardNamespaceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStandardNamespaceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49782,27 +49398,25 @@ - (void)subscribeAttributeStandardNamespaceWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStandardNamespaceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49810,7 +49424,8 @@ + (void)readAttributeStandardNamespaceWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
@@ -49819,9 +49434,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49831,14 +49445,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectSupportedModesListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectSupportedModesListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectSupportedModesListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
-            auto successFn = Callback<ModeSelectSupportedModesListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49847,27 +49461,26 @@ - (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
-                auto successFn = Callback<ModeSelectSupportedModesListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectSupportedModesListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportedModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49875,7 +49488,8 @@ + (void)readAttributeSupportedModesWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ModeSelectSupportedModesListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
@@ -49884,9 +49498,8 @@ new MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ModeSelectSupportedModesListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49896,14 +49509,14 @@ new MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -49912,26 +49525,25 @@ - (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -49939,7 +49551,8 @@ + (void)readAttributeCurrentModeWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
@@ -49948,9 +49561,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -49960,14 +49572,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -49982,12 +49594,13 @@ - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -50004,13 +49617,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStartUpModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50019,27 +49630,25 @@ - (void)subscribeAttributeStartUpModeWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStartUpModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50047,7 +49656,8 @@ + (void)readAttributeStartUpModeWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
@@ -50056,9 +49666,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -50068,14 +49677,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -50090,12 +49699,13 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -50112,13 +49722,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOnModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50127,27 +49735,25 @@ - (void)subscribeAttributeOnModeWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOnModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50155,7 +49761,8 @@ + (void)readAttributeOnModeWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
@@ -50164,9 +49771,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -50176,14 +49782,15 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ModeSelectGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ModeSelectGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50193,27 +49800,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ModeSelectGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ModeSelectGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50222,8 +49829,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ModeSelectGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
@@ -50232,9 +49840,8 @@ new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ModeSelectGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -50244,14 +49851,15 @@ new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ModeSelectAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ModeSelectAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50261,27 +49869,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ModeSelectAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ModeSelectAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50290,8 +49898,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ModeSelectAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
@@ -50300,9 +49909,8 @@ new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ModeSelectAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -50312,14 +49920,14 @@ new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ModeSelectAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50328,27 +49936,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ModeSelectAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50356,7 +49963,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRModeSelectAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRModeSelectAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ModeSelectAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
@@ -50365,9 +49973,8 @@ new MTRModeSelectAttributeListListAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ModeSelectAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -50377,14 +49984,14 @@ new MTRModeSelectAttributeListListAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50393,26 +50000,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50420,7 +50026,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
@@ -50429,9 +50036,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -50441,14 +50047,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -50457,26 +50063,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -50484,7 +50089,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
@@ -50493,9 +50099,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -50935,12 +50540,13 @@ - (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::LockDoor::Type request;
@@ -50959,23 +50565,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::UnlockDoor::Type request;
@@ -50994,23 +50600,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::UnlockWithTimeout::Type request;
@@ -51028,23 +50634,23 @@ new MTRCommandSuccessCallbackBridge(
                 definedValue_0 = [self asByteSpan:params.pinCode];
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::SetWeekDaySchedule::Type request;
@@ -51061,11 +50667,10 @@ new MTRCommandSuccessCallbackBridge(
             request.endHour = params.endHour.unsignedCharValue;
             request.endMinute = params.endMinute.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams *)params
@@ -51074,8 +50679,10 @@ - (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterGetWeekDayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::GetWeekDaySchedule::Type request;
@@ -51087,11 +50694,10 @@ new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueu
             request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
             request.userIndex = params.userIndex.unsignedShortValue;
 
-            auto successFn = Callback<DoorLockClusterGetWeekDayScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params
@@ -51099,12 +50705,13 @@ - (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDaySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::ClearWeekDaySchedule::Type request;
@@ -51116,23 +50723,23 @@ new MTRCommandSuccessCallbackBridge(
             request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
             request.userIndex = params.userIndex.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::SetYearDaySchedule::Type request;
@@ -51146,11 +50753,10 @@ new MTRCommandSuccessCallbackBridge(
             request.localStartTime = params.localStartTime.unsignedIntValue;
             request.localEndTime = params.localEndTime.unsignedIntValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams *)params
@@ -51159,8 +50765,10 @@ - (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterGetYearDayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::GetYearDaySchedule::Type request;
@@ -51172,11 +50780,10 @@ new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueu
             request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
             request.userIndex = params.userIndex.unsignedShortValue;
 
-            auto successFn = Callback<DoorLockClusterGetYearDayScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params
@@ -51184,12 +50791,13 @@ - (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDaySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::ClearYearDaySchedule::Type request;
@@ -51201,23 +50809,23 @@ new MTRCommandSuccessCallbackBridge(
             request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
             request.userIndex = params.userIndex.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::SetHolidaySchedule::Type request;
@@ -51232,11 +50840,10 @@ new MTRCommandSuccessCallbackBridge(
             request.operatingMode
                 = static_cast<std::remove_reference_t<decltype(request.operatingMode)>>(params.operatingMode.unsignedCharValue);
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams *)params
@@ -51245,8 +50852,10 @@ - (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterGetHolidayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::GetHolidaySchedule::Type request;
@@ -51257,11 +50866,10 @@ new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueu
             }
             request.holidayIndex = params.holidayIndex.unsignedCharValue;
 
-            auto successFn = Callback<DoorLockClusterGetHolidayScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params
@@ -51269,12 +50877,13 @@ - (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidaySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::ClearHolidaySchedule::Type request;
@@ -51285,23 +50894,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.holidayIndex = params.holidayIndex.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::SetUser::Type request;
@@ -51349,11 +50958,10 @@ new MTRCommandSuccessCallbackBridge(
                     = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.credentialRule.unsignedCharValue);
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
@@ -51361,8 +50969,9 @@ - (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockClusterGetUserResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::GetUser::Type request;
@@ -51373,23 +50982,23 @@ new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, self.dev
             }
             request.userIndex = params.userIndex.unsignedShortValue;
 
-            auto successFn = Callback<DoorLockClusterGetUserResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::ClearUser::Type request;
@@ -51403,11 +51012,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.userIndex = params.userIndex.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
@@ -51416,8 +51024,10 @@ - (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterSetCredentialResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::SetCredential::Type request;
@@ -51455,11 +51065,10 @@ new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, se
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userType.unsignedCharValue);
             }
 
-            auto successFn = Callback<DoorLockClusterSetCredentialResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params
@@ -51468,8 +51077,10 @@ - (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterGetCredentialStatusResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::GetCredentialStatus::Type request;
@@ -51482,23 +51093,23 @@ new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQue
                 params.credential.credentialType.unsignedCharValue);
             request.credential.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
 
-            auto successFn = Callback<DoorLockClusterGetCredentialStatusResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             DoorLock::Commands::ClearCredential::Type request;
@@ -51519,23 +51130,23 @@ new MTRCommandSuccessCallbackBridge(
                 nonNullValue_0.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeLockStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableDoorLockClusterDlLockStateAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
-            auto successFn = Callback<NullableDoorLockClusterDlLockStateAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLockStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -51544,27 +51155,27 @@ - (void)subscribeAttributeLockStateWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
-                auto successFn = Callback<NullableDoorLockClusterDlLockStateAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableDoorLockClusterDlLockStateAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLockStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -51572,8 +51183,9 @@ + (void)readAttributeLockStateWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableDoorLockClusterDlLockStateAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
@@ -51582,9 +51194,8 @@ new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NullableDoorLockClusterDlLockStateAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -51594,14 +51205,14 @@ new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(
 
 - (void)readAttributeLockTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockClusterDlLockTypeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
-            auto successFn = Callback<DoorLockClusterDlLockTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLockTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -51610,27 +51221,26 @@ - (void)subscribeAttributeLockTypeWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
-                auto successFn = Callback<DoorLockClusterDlLockTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockClusterDlLockTypeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLockTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -51638,7 +51248,8 @@ + (void)readAttributeLockTypeWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DoorLockClusterDlLockTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
@@ -51647,9 +51258,8 @@ new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, completion, ^(Can
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoorLockClusterDlLockTypeAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -51659,14 +51269,14 @@ new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, completion, ^(Can
 
 - (void)readAttributeActuatorEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActuatorEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -51675,26 +51285,25 @@ - (void)subscribeAttributeActuatorEnabledWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActuatorEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -51702,7 +51311,8 @@ + (void)readAttributeActuatorEnabledWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
@@ -51711,9 +51321,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -51723,14 +51332,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDoorStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableDoorLockClusterDlDoorStateAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
-            auto successFn = Callback<NullableDoorLockClusterDlDoorStateAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDoorStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -51739,27 +51349,27 @@ - (void)subscribeAttributeDoorStateWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
-                auto successFn = Callback<NullableDoorLockClusterDlDoorStateAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableDoorLockClusterDlDoorStateAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDoorStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -51767,8 +51377,9 @@ + (void)readAttributeDoorStateWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableDoorLockClusterDlDoorStateAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
@@ -51777,9 +51388,8 @@ new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NullableDoorLockClusterDlDoorStateAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -51789,14 +51399,14 @@ new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(
 
 - (void)readAttributeDoorOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -51811,12 +51421,13 @@ - (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -51828,13 +51439,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDoorOpenEventsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -51843,26 +51452,25 @@ - (void)subscribeAttributeDoorOpenEventsWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDoorOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -51870,7 +51478,8 @@ + (void)readAttributeDoorOpenEventsWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
@@ -51879,9 +51488,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -51891,14 +51499,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDoorClosedEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -51913,12 +51521,13 @@ - (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -51930,13 +51539,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDoorClosedEventsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -51945,26 +51552,25 @@ - (void)subscribeAttributeDoorClosedEventsWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDoorClosedEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -51972,7 +51578,8 @@ + (void)readAttributeDoorClosedEventsWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
@@ -51981,9 +51588,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -51993,14 +51599,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -52015,12 +51621,13 @@ - (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -52032,13 +51639,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOpenPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52047,26 +51652,25 @@ - (void)subscribeAttributeOpenPeriodWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52074,7 +51678,8 @@ + (void)readAttributeOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
@@ -52083,9 +51688,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52096,14 +51700,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeNumberOfTotalUsersSupportedWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfTotalUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52113,26 +51717,25 @@ - (void)subscribeAttributeNumberOfTotalUsersSupportedWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfTotalUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52141,7 +51744,8 @@ + (void)readAttributeNumberOfTotalUsersSupportedWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
@@ -52150,9 +51754,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52163,14 +51766,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeNumberOfPINUsersSupportedWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfPINUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52180,26 +51783,25 @@ - (void)subscribeAttributeNumberOfPINUsersSupportedWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfPINUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52208,7 +51810,8 @@ + (void)readAttributeNumberOfPINUsersSupportedWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
@@ -52217,9 +51820,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52230,14 +51832,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeNumberOfRFIDUsersSupportedWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfRFIDUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52247,26 +51849,25 @@ - (void)subscribeAttributeNumberOfRFIDUsersSupportedWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfRFIDUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52275,7 +51876,8 @@ + (void)readAttributeNumberOfRFIDUsersSupportedWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
@@ -52284,9 +51886,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52297,14 +51898,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52315,26 +51916,25 @@ - (void)subscribeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithParams:(MT
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithAttributeCache:
@@ -52344,7 +51944,8 @@ + (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithAttributeCache:
                                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
@@ -52353,9 +51954,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52366,14 +51966,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfYearDaySchedulesSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52384,26 +51984,25 @@ - (void)subscribeAttributeNumberOfYearDaySchedulesSupportedPerUserWithParams:(MT
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithAttributeCache:
@@ -52413,7 +52012,8 @@ + (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithAttributeCache:
                                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
@@ -52422,9 +52022,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52435,14 +52034,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeNumberOfHolidaySchedulesSupportedWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfHolidaySchedulesSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52453,26 +52052,25 @@ - (void)subscribeAttributeNumberOfHolidaySchedulesSupportedWithParams:(MTRSubscr
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfHolidaySchedulesSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52481,7 +52079,8 @@ + (void)readAttributeNumberOfHolidaySchedulesSupportedWithAttributeCache:(MTRAtt
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
@@ -52490,9 +52089,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52502,14 +52100,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMaxPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxPINCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52518,26 +52116,25 @@ - (void)subscribeAttributeMaxPINCodeLengthWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52545,7 +52142,8 @@ + (void)readAttributeMaxPINCodeLengthWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
@@ -52554,9 +52152,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52566,14 +52163,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMinPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinPINCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52582,26 +52179,25 @@ - (void)subscribeAttributeMinPINCodeLengthWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52609,7 +52205,8 @@ + (void)readAttributeMinPINCodeLengthWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
@@ -52618,9 +52215,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52630,14 +52226,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMaxRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxRFIDCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52646,26 +52242,25 @@ - (void)subscribeAttributeMaxRFIDCodeLengthWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52673,7 +52268,8 @@ + (void)readAttributeMaxRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
@@ -52682,9 +52278,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52694,14 +52289,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMinRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinRFIDCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52710,26 +52305,25 @@ - (void)subscribeAttributeMinRFIDCodeLengthWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52737,7 +52331,8 @@ + (void)readAttributeMinRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
@@ -52746,9 +52341,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52759,14 +52353,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeCredentialRulesSupportWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockCredentialRulesSupportAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
-            auto successFn = Callback<DoorLockCredentialRulesSupportAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCredentialRulesSupportWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52776,27 +52370,26 @@ - (void)subscribeAttributeCredentialRulesSupportWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
-                auto successFn = Callback<DoorLockCredentialRulesSupportAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockCredentialRulesSupportAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCredentialRulesSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52805,36 +52398,37 @@ + (void)readAttributeCredentialRulesSupportWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoorLockCredentialRulesSupportAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockCredentialRulesSupportAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeNumberOfCredentialsSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfCredentialsSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52845,26 +52439,25 @@ - (void)subscribeAttributeNumberOfCredentialsSupportedPerUserWithParams:(MTRSubs
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfCredentialsSupportedPerUserWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52873,7 +52466,8 @@ + (void)readAttributeNumberOfCredentialsSupportedPerUserWithAttributeCache:(MTRA
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
@@ -52882,9 +52476,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52894,14 +52487,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeLanguageWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -52916,12 +52509,13 @@ - (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -52933,13 +52527,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLanguageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -52948,27 +52540,25 @@ - (void)subscribeAttributeLanguageWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLanguageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -52976,7 +52566,8 @@ + (void)readAttributeLanguageWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
@@ -52985,9 +52576,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -52997,14 +52587,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeLEDSettingsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53019,12 +52609,13 @@ - (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53036,13 +52627,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLEDSettingsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53051,26 +52640,25 @@ - (void)subscribeAttributeLEDSettingsWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLEDSettingsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53078,7 +52666,8 @@ + (void)readAttributeLEDSettingsWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
@@ -53087,9 +52676,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53099,14 +52687,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeAutoRelockTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53121,12 +52709,13 @@ - (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53138,13 +52727,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAutoRelockTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53153,26 +52740,25 @@ - (void)subscribeAttributeAutoRelockTimeWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAutoRelockTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53180,7 +52766,8 @@ + (void)readAttributeAutoRelockTimeWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
@@ -53189,9 +52776,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53201,14 +52787,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeSoundVolumeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53223,12 +52809,13 @@ - (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53240,13 +52827,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSoundVolumeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53255,26 +52840,25 @@ - (void)subscribeAttributeSoundVolumeWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSoundVolumeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53282,7 +52866,8 @@ + (void)readAttributeSoundVolumeWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
@@ -53291,9 +52876,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53303,14 +52887,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeOperatingModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterDlOperatingModeAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
-            auto successFn = Callback<DoorLockClusterDlOperatingModeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53325,12 +52909,13 @@ - (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53342,13 +52927,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOperatingModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53357,27 +52940,26 @@ - (void)subscribeAttributeOperatingModeWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
-                auto successFn = Callback<DoorLockClusterDlOperatingModeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockClusterDlOperatingModeAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOperatingModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53385,36 +52967,38 @@ + (void)readAttributeOperatingModeWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoorLockClusterDlOperatingModeAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockClusterDlOperatingModeAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeSupportedOperatingModesWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockSupportedOperatingModesAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
-            auto successFn = Callback<DoorLockSupportedOperatingModesAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportedOperatingModesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53424,27 +53008,27 @@ - (void)subscribeAttributeSupportedOperatingModesWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
-                auto successFn = Callback<DoorLockSupportedOperatingModesAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockSupportedOperatingModesAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportedOperatingModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53453,36 +53037,38 @@ + (void)readAttributeSupportedOperatingModesWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoorLockSupportedOperatingModesAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockSupportedOperatingModesAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeDefaultConfigurationRegisterWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockDefaultConfigurationRegisterAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
-            auto successFn = Callback<DoorLockDefaultConfigurationRegisterAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDefaultConfigurationRegisterWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53493,27 +53079,27 @@ - (void)subscribeAttributeDefaultConfigurationRegisterWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
-                auto successFn = Callback<DoorLockDefaultConfigurationRegisterAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockDefaultConfigurationRegisterAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDefaultConfigurationRegisterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53522,8 +53108,9 @@ + (void)readAttributeDefaultConfigurationRegisterWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockDefaultConfigurationRegisterAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
@@ -53532,9 +53119,8 @@ new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DoorLockDefaultConfigurationRegisterAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -53545,14 +53131,14 @@ new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(
 - (void)readAttributeEnableLocalProgrammingWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53567,12 +53153,13 @@ - (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53584,13 +53171,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnableLocalProgrammingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53600,26 +53185,25 @@ - (void)subscribeAttributeEnableLocalProgrammingWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnableLocalProgrammingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53628,7 +53212,8 @@ + (void)readAttributeEnableLocalProgrammingWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
@@ -53637,9 +53222,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53649,14 +53233,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeEnableOneTouchLockingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53671,12 +53255,13 @@ - (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53688,13 +53273,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnableOneTouchLockingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53704,26 +53287,25 @@ - (void)subscribeAttributeEnableOneTouchLockingWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnableOneTouchLockingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53732,7 +53314,8 @@ + (void)readAttributeEnableOneTouchLockingWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
@@ -53741,9 +53324,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53753,14 +53335,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeEnableInsideStatusLEDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53775,12 +53357,13 @@ - (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53792,13 +53375,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnableInsideStatusLEDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53808,26 +53389,25 @@ - (void)subscribeAttributeEnableInsideStatusLEDWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnableInsideStatusLEDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53836,7 +53416,8 @@ + (void)readAttributeEnableInsideStatusLEDWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
@@ -53845,9 +53426,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53858,14 +53438,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeEnablePrivacyModeButtonWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53880,12 +53460,13 @@ - (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -53897,13 +53478,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnablePrivacyModeButtonWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -53913,26 +53492,25 @@ - (void)subscribeAttributeEnablePrivacyModeButtonWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnablePrivacyModeButtonWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -53941,7 +53519,8 @@ + (void)readAttributeEnablePrivacyModeButtonWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
@@ -53950,9 +53529,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -53963,14 +53541,15 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeLocalProgrammingFeaturesWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockLocalProgrammingFeaturesAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
-            auto successFn = Callback<DoorLockLocalProgrammingFeaturesAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -53985,12 +53564,13 @@ - (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)val
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -54002,13 +53582,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLocalProgrammingFeaturesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54018,27 +53596,27 @@ - (void)subscribeAttributeLocalProgrammingFeaturesWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
-                auto successFn = Callback<DoorLockLocalProgrammingFeaturesAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockLocalProgrammingFeaturesAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLocalProgrammingFeaturesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54047,8 +53625,9 @@ + (void)readAttributeLocalProgrammingFeaturesWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockLocalProgrammingFeaturesAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
@@ -54057,9 +53636,8 @@ new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DoorLockLocalProgrammingFeaturesAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -54069,14 +53647,14 @@ new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(
 
 - (void)readAttributeWrongCodeEntryLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -54091,12 +53669,13 @@ - (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -54108,13 +53687,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWrongCodeEntryLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54124,26 +53701,25 @@ - (void)subscribeAttributeWrongCodeEntryLimitWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWrongCodeEntryLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54152,7 +53728,8 @@ + (void)readAttributeWrongCodeEntryLimitWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
@@ -54161,9 +53738,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54174,14 +53750,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeUserCodeTemporaryDisableTimeWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -54196,12 +53772,13 @@ - (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -54213,13 +53790,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUserCodeTemporaryDisableTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54230,26 +53805,25 @@ - (void)subscribeAttributeUserCodeTemporaryDisableTimeWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUserCodeTemporaryDisableTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54258,7 +53832,8 @@ + (void)readAttributeUserCodeTemporaryDisableTimeWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
@@ -54267,9 +53842,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54279,14 +53853,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeSendPINOverTheAirWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -54301,12 +53875,13 @@ - (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -54318,13 +53893,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSendPINOverTheAirWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54333,26 +53906,25 @@ - (void)subscribeAttributeSendPINOverTheAirWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSendPINOverTheAirWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54360,7 +53932,8 @@ + (void)readAttributeSendPINOverTheAirWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
@@ -54369,9 +53942,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54382,14 +53954,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRequirePINforRemoteOperationWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -54404,12 +53976,13 @@ - (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -54421,13 +53994,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRequirePINforRemoteOperationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54438,26 +54009,25 @@ - (void)subscribeAttributeRequirePINforRemoteOperationWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRequirePINforRemoteOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54466,7 +54036,8 @@ + (void)readAttributeRequirePINforRemoteOperationWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
@@ -54475,9 +54046,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54487,14 +54057,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeExpiringUserTimeoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -54509,12 +54079,13 @@ - (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -54526,13 +54097,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeExpiringUserTimeoutWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54542,26 +54111,25 @@ - (void)subscribeAttributeExpiringUserTimeoutWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeExpiringUserTimeoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54570,7 +54138,8 @@ + (void)readAttributeExpiringUserTimeoutWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
@@ -54579,9 +54148,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54591,14 +54159,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<DoorLockGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54608,27 +54177,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<DoorLockGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54637,8 +54206,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
@@ -54647,9 +54217,8 @@ new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<DoorLockGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -54659,14 +54228,15 @@ new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<DoorLockAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54676,27 +54246,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<DoorLockAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            DoorLockAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54705,35 +54275,36 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoorLockAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(DoorLockAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<DoorLockAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54742,27 +54313,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<DoorLockAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54770,7 +54340,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoorLockAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoorLockAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DoorLockAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
@@ -54779,9 +54350,8 @@ new MTRDoorLockAttributeListListAttributeCallbackBridge(queue, completion, ^(Can
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoorLockAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54791,14 +54361,14 @@ new MTRDoorLockAttributeListListAttributeCallbackBridge(queue, completion, ^(Can
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54807,26 +54377,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54834,7 +54403,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
@@ -54843,9 +54413,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -54855,14 +54424,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -54871,26 +54440,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -54898,7 +54466,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
@@ -54907,9 +54476,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -56681,12 +56249,13 @@ - (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::UpOrOpen::Type request;
@@ -56696,11 +56265,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)downOrCloseWithCompletion:(MTRStatusCompletion)completion
@@ -56712,12 +56280,13 @@ - (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Null
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::DownOrClose::Type request;
@@ -56727,11 +56296,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopMotionWithCompletion:(MTRStatusCompletion)completion
@@ -56742,12 +56310,13 @@ - (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullab
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::StopMotion::Type request;
@@ -56757,23 +56326,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::GoToLiftValue::Type request;
@@ -56784,11 +56353,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.liftValue = params.liftValue.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params
@@ -56796,12 +56364,13 @@ - (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentage
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::GoToLiftPercentage::Type request;
@@ -56812,23 +56381,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.liftPercent100thsValue = params.liftPercent100thsValue.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::GoToTiltValue::Type request;
@@ -56839,11 +56408,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.tiltValue = params.tiltValue.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params
@@ -56851,12 +56419,13 @@ - (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentage
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             WindowCovering::Commands::GoToTiltPercentage::Type request;
@@ -56867,23 +56436,22 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.tiltPercent100thsValue = params.tiltPercent100thsValue.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringClusterTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringClusterTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringClusterTypeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
-            auto successFn = Callback<WindowCoveringClusterTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -56892,27 +56460,26 @@ - (void)subscribeAttributeTypeWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
-                auto successFn = Callback<WindowCoveringClusterTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringClusterTypeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -56920,7 +56487,8 @@ + (void)readAttributeTypeWithAttributeCache:(MTRAttributeCacheContainer *)attrib
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(WindowCoveringClusterTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
@@ -56929,9 +56497,8 @@ new MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, completion, ^(Can
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WindowCoveringClusterTypeAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -56942,14 +56509,14 @@ new MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, completion, ^(Can
 - (void)readAttributePhysicalClosedLimitLiftWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalClosedLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -56959,26 +56526,25 @@ - (void)subscribeAttributePhysicalClosedLimitLiftWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -56987,7 +56553,8 @@ + (void)readAttributePhysicalClosedLimitLiftWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
@@ -56996,9 +56563,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57009,14 +56575,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributePhysicalClosedLimitTiltWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalClosedLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57026,26 +56592,25 @@ - (void)subscribeAttributePhysicalClosedLimitTiltWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57054,7 +56619,8 @@ + (void)readAttributePhysicalClosedLimitTiltWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
@@ -57063,9 +56629,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57075,14 +56640,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCurrentPositionLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionLiftWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57092,27 +56657,25 @@ - (void)subscribeAttributeCurrentPositionLiftWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57121,7 +56684,8 @@ + (void)readAttributeCurrentPositionLiftWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
@@ -57130,9 +56694,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57142,14 +56705,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeCurrentPositionTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionTiltWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57159,27 +56722,25 @@ - (void)subscribeAttributeCurrentPositionTiltWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57188,7 +56749,8 @@ + (void)readAttributeCurrentPositionTiltWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
@@ -57197,9 +56759,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57210,14 +56771,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeNumberOfActuationsLiftWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfActuationsLiftWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57227,26 +56788,25 @@ - (void)subscribeAttributeNumberOfActuationsLiftWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfActuationsLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57255,7 +56815,8 @@ + (void)readAttributeNumberOfActuationsLiftWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
@@ -57264,9 +56825,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57277,14 +56837,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeNumberOfActuationsTiltWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfActuationsTiltWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57294,26 +56854,25 @@ - (void)subscribeAttributeNumberOfActuationsTiltWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfActuationsTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57322,7 +56881,8 @@ + (void)readAttributeNumberOfActuationsTiltWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
@@ -57331,9 +56891,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57343,14 +56902,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeConfigStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringConfigStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringConfigStatusAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringConfigStatusAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
-            auto successFn = Callback<WindowCoveringConfigStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeConfigStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57359,27 +56918,26 @@ - (void)subscribeAttributeConfigStatusWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
-                auto successFn = Callback<WindowCoveringConfigStatusAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringConfigStatusAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeConfigStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57387,7 +56945,8 @@ + (void)readAttributeConfigStatusWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(WindowCoveringConfigStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
@@ -57396,9 +56955,8 @@ new MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, completion, ^(Ca
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WindowCoveringConfigStatusAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57409,14 +56967,14 @@ new MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, completion, ^(Ca
 - (void)readAttributeCurrentPositionLiftPercentageWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionLiftPercentageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57427,27 +56985,25 @@ - (void)subscribeAttributeCurrentPositionLiftPercentageWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionLiftPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57456,7 +57012,8 @@ + (void)readAttributeCurrentPositionLiftPercentageWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
@@ -57465,9 +57022,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57478,14 +57034,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 - (void)readAttributeCurrentPositionTiltPercentageWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionTiltPercentageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57496,27 +57052,25 @@ - (void)subscribeAttributeCurrentPositionTiltPercentageWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionTiltPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57525,7 +57079,8 @@ + (void)readAttributeCurrentPositionTiltPercentageWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
@@ -57534,9 +57089,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57546,14 +57100,15 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeOperationalStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringOperationalStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
-            auto successFn = Callback<WindowCoveringOperationalStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOperationalStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57562,27 +57117,27 @@ - (void)subscribeAttributeOperationalStatusWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
-                auto successFn = Callback<WindowCoveringOperationalStatusAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringOperationalStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOperationalStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57590,36 +57145,37 @@ + (void)readAttributeOperationalStatusWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WindowCoveringOperationalStatusAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WindowCoveringOperationalStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeTargetPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTargetPositionLiftPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57630,27 +57186,25 @@ - (void)subscribeAttributeTargetPositionLiftPercent100thsWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTargetPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57659,7 +57213,8 @@ + (void)readAttributeTargetPositionLiftPercent100thsWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
@@ -57668,9 +57223,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57681,14 +57235,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeTargetPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTargetPositionTiltPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57699,27 +57253,25 @@ - (void)subscribeAttributeTargetPositionTiltPercent100thsWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTargetPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57728,7 +57280,8 @@ + (void)readAttributeTargetPositionTiltPercent100thsWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
@@ -57737,9 +57290,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57749,14 +57301,15 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeEndProductTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringClusterEndProductTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
-            auto successFn = Callback<WindowCoveringClusterEndProductTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEndProductTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57765,27 +57318,27 @@ - (void)subscribeAttributeEndProductTypeWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
-                auto successFn = Callback<WindowCoveringClusterEndProductTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringClusterEndProductTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEndProductTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57793,8 +57346,9 @@ + (void)readAttributeEndProductTypeWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WindowCoveringClusterEndProductTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
@@ -57803,9 +57357,8 @@ new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WindowCoveringClusterEndProductTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -57816,14 +57369,14 @@ new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(
 - (void)readAttributeCurrentPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionLiftPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57834,27 +57387,25 @@ - (void)subscribeAttributeCurrentPositionLiftPercent100thsWithParams:(MTRSubscri
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57863,7 +57414,8 @@ + (void)readAttributeCurrentPositionLiftPercent100thsWithAttributeCache:(MTRAttr
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
@@ -57872,9 +57424,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57885,14 +57436,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeCurrentPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentPositionTiltPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57903,27 +57454,25 @@ - (void)subscribeAttributeCurrentPositionTiltPercent100thsWithParams:(MTRSubscri
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57932,7 +57481,8 @@ + (void)readAttributeCurrentPositionTiltPercent100thsWithAttributeCache:(MTRAttr
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
@@ -57941,9 +57491,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -57954,14 +57503,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeInstalledOpenLimitLiftWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstalledOpenLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -57971,26 +57520,25 @@ - (void)subscribeAttributeInstalledOpenLimitLiftWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstalledOpenLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -57999,7 +57547,8 @@ + (void)readAttributeInstalledOpenLimitLiftWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
@@ -58008,9 +57557,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58021,14 +57569,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeInstalledClosedLimitLiftWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstalledClosedLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58038,26 +57586,25 @@ - (void)subscribeAttributeInstalledClosedLimitLiftWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstalledClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58066,7 +57613,8 @@ + (void)readAttributeInstalledClosedLimitLiftWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
@@ -58075,9 +57623,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58088,14 +57635,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeInstalledOpenLimitTiltWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstalledOpenLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58105,26 +57652,25 @@ - (void)subscribeAttributeInstalledOpenLimitTiltWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstalledOpenLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58133,7 +57679,8 @@ + (void)readAttributeInstalledOpenLimitTiltWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
@@ -58142,9 +57689,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58155,14 +57701,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeInstalledClosedLimitTiltWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstalledClosedLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58172,26 +57718,25 @@ - (void)subscribeAttributeInstalledClosedLimitTiltWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstalledClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58200,7 +57745,8 @@ + (void)readAttributeInstalledClosedLimitTiltWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
@@ -58209,9 +57755,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58221,14 +57766,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringModeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringModeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
-            auto successFn = Callback<WindowCoveringModeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -58243,12 +57788,13 @@ - (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -58260,13 +57806,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58275,27 +57819,25 @@ - (void)subscribeAttributeModeWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringModeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
-                auto successFn = Callback<WindowCoveringModeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringModeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringModeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringModeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58303,7 +57845,8 @@ + (void)readAttributeModeWithAttributeCache:(MTRAttributeCacheContainer *)attrib
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringModeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringModeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(WindowCoveringModeAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
@@ -58312,9 +57855,8 @@ new MTRWindowCoveringModeAttributeCallbackBridge(queue, completion, ^(Cancelable
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WindowCoveringModeAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58324,14 +57866,14 @@ new MTRWindowCoveringModeAttributeCallbackBridge(queue, completion, ^(Cancelable
 
 - (void)readAttributeSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringSafetyStatusAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
-            auto successFn = Callback<WindowCoveringSafetyStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58340,27 +57882,26 @@ - (void)subscribeAttributeSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
-                auto successFn = Callback<WindowCoveringSafetyStatusAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringSafetyStatusAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58368,7 +57909,8 @@ + (void)readAttributeSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(WindowCoveringSafetyStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
@@ -58377,9 +57919,8 @@ new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, completion, ^(Ca
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WindowCoveringSafetyStatusAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58389,14 +57930,15 @@ new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, completion, ^(Ca
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<WindowCoveringGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58406,27 +57948,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<WindowCoveringGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58435,8 +57978,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WindowCoveringGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
@@ -58445,9 +57989,8 @@ new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WindowCoveringGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -58457,14 +58000,15 @@ new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<WindowCoveringAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58474,27 +58018,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<WindowCoveringAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58503,8 +58047,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WindowCoveringAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
@@ -58513,9 +58058,8 @@ new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WindowCoveringAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -58525,14 +58069,15 @@ new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWindowCoveringAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<WindowCoveringAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58541,27 +58086,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<WindowCoveringAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WindowCoveringAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58569,35 +58114,36 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WindowCoveringAttributeListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WindowCoveringAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58606,26 +58152,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58633,7 +58178,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
@@ -58642,9 +58188,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -58654,14 +58199,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -58670,26 +58215,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -58697,7 +58241,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
@@ -58706,9 +58251,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -59752,12 +59296,13 @@ - (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierCont
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             BarrierControl::Commands::BarrierControlGoToPercent::Type request;
@@ -59768,11 +59313,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.percentOpen = params.percentOpen.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)barrierControlStopWithCompletion:(MTRStatusCompletion)completion
@@ -59784,12 +59328,13 @@ - (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStop
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             BarrierControl::Commands::BarrierControlStop::Type request;
@@ -59799,23 +59344,22 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeBarrierMovingStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierMovingStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -59825,26 +59369,25 @@ - (void)subscribeAttributeBarrierMovingStateWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierMovingStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -59853,7 +59396,8 @@ + (void)readAttributeBarrierMovingStateWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
@@ -59862,9 +59406,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -59874,14 +59417,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeBarrierSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -59891,26 +59434,25 @@ - (void)subscribeAttributeBarrierSafetyStatusWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -59919,7 +59461,8 @@ + (void)readAttributeBarrierSafetyStatusWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
@@ -59928,9 +59471,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -59940,14 +59482,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBarrierCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierCapabilitiesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -59957,26 +59499,25 @@ - (void)subscribeAttributeBarrierCapabilitiesWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -59985,7 +59526,8 @@ + (void)readAttributeBarrierCapabilitiesWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
@@ -59994,9 +59536,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60006,14 +59547,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeBarrierOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -60028,12 +59569,13 @@ - (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -60045,13 +59587,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierOpenEventsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60060,26 +59600,25 @@ - (void)subscribeAttributeBarrierOpenEventsWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60087,7 +59626,8 @@ + (void)readAttributeBarrierOpenEventsWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
@@ -60096,9 +59636,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60108,14 +59647,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBarrierCloseEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -60130,12 +59669,13 @@ - (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -60147,13 +59687,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierCloseEventsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60163,26 +59701,25 @@ - (void)subscribeAttributeBarrierCloseEventsWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60191,7 +59728,8 @@ + (void)readAttributeBarrierCloseEventsWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
@@ -60200,9 +59738,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60213,14 +59750,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeBarrierCommandOpenEventsWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -60235,12 +59772,13 @@ - (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)val
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -60252,13 +59790,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierCommandOpenEventsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60268,26 +59804,25 @@ - (void)subscribeAttributeBarrierCommandOpenEventsWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierCommandOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60296,7 +59831,8 @@ + (void)readAttributeBarrierCommandOpenEventsWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
@@ -60305,9 +59841,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60318,14 +59853,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeBarrierCommandCloseEventsWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -60340,12 +59875,13 @@ - (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)va
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -60357,13 +59893,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierCommandCloseEventsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60373,26 +59907,25 @@ - (void)subscribeAttributeBarrierCommandCloseEventsWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierCommandCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60401,7 +59934,8 @@ + (void)readAttributeBarrierCommandCloseEventsWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
@@ -60410,9 +59944,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60422,14 +59955,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBarrierOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -60444,12 +59977,13 @@ - (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -60461,13 +59995,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierOpenPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60476,26 +60008,25 @@ - (void)subscribeAttributeBarrierOpenPeriodWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60503,7 +60034,8 @@ + (void)readAttributeBarrierOpenPeriodWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
@@ -60512,9 +60044,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60524,14 +60055,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBarrierClosePeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -60546,12 +60077,13 @@ - (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -60563,13 +60095,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierClosePeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60579,26 +60109,25 @@ - (void)subscribeAttributeBarrierClosePeriodWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierClosePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60607,7 +60136,8 @@ + (void)readAttributeBarrierClosePeriodWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
@@ -60616,9 +60146,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60628,14 +60157,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBarrierPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBarrierPositionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60644,26 +60173,25 @@ - (void)subscribeAttributeBarrierPositionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBarrierPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60671,7 +60199,8 @@ + (void)readAttributeBarrierPositionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
@@ -60680,9 +60209,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60692,14 +60220,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BarrierControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BarrierControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60709,27 +60238,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BarrierControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BarrierControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60738,8 +60268,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BarrierControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
@@ -60748,9 +60279,8 @@ new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BarrierControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -60760,14 +60290,15 @@ new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BarrierControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BarrierControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60777,27 +60308,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BarrierControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BarrierControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60806,8 +60337,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BarrierControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
@@ -60816,9 +60348,8 @@ new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BarrierControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -60828,14 +60359,15 @@ new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBarrierControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBarrierControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BarrierControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BarrierControlAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60844,27 +60376,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BarrierControlAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BarrierControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60872,35 +60404,36 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BarrierControlAttributeListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BarrierControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60909,26 +60442,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -60936,7 +60468,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
@@ -60945,9 +60478,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -60957,14 +60489,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -60973,26 +60505,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -61000,7 +60531,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
@@ -61009,9 +60541,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -61659,14 +61190,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMaxPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxPressureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -61675,27 +61206,25 @@ - (void)subscribeAttributeMaxPressureWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -61703,7 +61232,8 @@ + (void)readAttributeMaxPressureWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
@@ -61712,9 +61242,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -61724,14 +61253,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -61740,27 +61269,25 @@ - (void)subscribeAttributeMaxSpeedWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -61768,7 +61295,8 @@ + (void)readAttributeMaxSpeedWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
@@ -61777,9 +61305,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -61789,14 +61316,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxFlowWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -61805,27 +61332,25 @@ - (void)subscribeAttributeMaxFlowWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -61833,7 +61358,8 @@ + (void)readAttributeMaxFlowWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
@@ -61842,9 +61368,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -61854,14 +61379,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinConstPressureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -61870,27 +61395,25 @@ - (void)subscribeAttributeMinConstPressureWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -61898,7 +61421,8 @@ + (void)readAttributeMinConstPressureWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
@@ -61907,9 +61431,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -61919,14 +61442,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxConstPressureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -61935,27 +61458,25 @@ - (void)subscribeAttributeMaxConstPressureWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -61963,7 +61484,8 @@ + (void)readAttributeMaxConstPressureWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
@@ -61972,9 +61494,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -61984,14 +61505,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinCompPressureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62000,27 +61521,25 @@ - (void)subscribeAttributeMinCompPressureWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62028,7 +61547,8 @@ + (void)readAttributeMinCompPressureWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
@@ -62037,9 +61557,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62049,14 +61568,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxCompPressureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62065,27 +61584,25 @@ - (void)subscribeAttributeMaxCompPressureWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62093,7 +61610,8 @@ + (void)readAttributeMaxCompPressureWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
@@ -62102,9 +61620,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62114,14 +61631,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinConstSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62130,27 +61647,25 @@ - (void)subscribeAttributeMinConstSpeedWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62158,7 +61673,8 @@ + (void)readAttributeMinConstSpeedWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
@@ -62167,9 +61683,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62179,14 +61694,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxConstSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62195,27 +61710,25 @@ - (void)subscribeAttributeMaxConstSpeedWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62223,7 +61736,8 @@ + (void)readAttributeMaxConstSpeedWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
@@ -62232,9 +61746,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62244,14 +61757,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinConstFlowWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62260,27 +61773,25 @@ - (void)subscribeAttributeMinConstFlowWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62288,7 +61799,8 @@ + (void)readAttributeMinConstFlowWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
@@ -62297,9 +61809,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62309,14 +61820,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxConstFlowWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62325,27 +61836,25 @@ - (void)subscribeAttributeMaxConstFlowWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62353,7 +61862,8 @@ + (void)readAttributeMaxConstFlowWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
@@ -62362,9 +61872,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62374,14 +61883,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinConstTempWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62390,27 +61899,25 @@ - (void)subscribeAttributeMinConstTempWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62418,7 +61925,8 @@ + (void)readAttributeMinConstTempWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
@@ -62427,9 +61935,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62439,14 +61946,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxConstTempWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62455,27 +61962,25 @@ - (void)subscribeAttributeMaxConstTempWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62483,7 +61988,8 @@ + (void)readAttributeMaxConstTempWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
@@ -62492,9 +61998,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62504,14 +62009,15 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributePumpStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlPumpStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
-            auto successFn = Callback<PumpConfigurationAndControlPumpStatusAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePumpStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62520,27 +62026,27 @@ - (void)subscribeAttributePumpStatusWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
-                auto successFn = Callback<PumpConfigurationAndControlPumpStatusAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlPumpStatusAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePumpStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62548,8 +62054,9 @@ + (void)readAttributePumpStatusWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlPumpStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
@@ -62558,9 +62065,8 @@ new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PumpConfigurationAndControlPumpStatusAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -62571,15 +62077,16 @@ new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(
 - (void)readAttributeEffectiveOperationModeWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
-            auto successFn
-                = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
+                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEffectiveOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62589,30 +62096,29 @@ - (void)subscribeAttributeEffectiveOperationModeWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEffectiveOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62621,8 +62127,9 @@ + (void)readAttributeEffectiveOperationModeWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
@@ -62631,10 +62138,8 @@ new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridg
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -62644,14 +62149,15 @@ new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridg
 
 - (void)readAttributeEffectiveControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
-            auto successFn = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEffectiveControlModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62661,30 +62167,28 @@ - (void)subscribeAttributeEffectiveControlModeWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEffectiveControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62693,8 +62197,9 @@ + (void)readAttributeEffectiveControlModeWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
@@ -62703,10 +62208,8 @@ new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -62716,14 +62219,14 @@ new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
 
 - (void)readAttributeCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62732,27 +62235,25 @@ - (void)subscribeAttributeCapacityWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62760,7 +62261,8 @@ + (void)readAttributeCapacityWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
@@ -62769,9 +62271,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62781,14 +62282,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62797,27 +62298,25 @@ - (void)subscribeAttributeSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62825,7 +62324,8 @@ + (void)readAttributeSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
@@ -62834,9 +62334,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62846,14 +62345,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeLifetimeRunningHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -62868,12 +62367,13 @@ - (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -62890,13 +62390,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLifetimeRunningHoursWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62906,27 +62404,25 @@ - (void)subscribeAttributeLifetimeRunningHoursWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLifetimeRunningHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -62935,7 +62431,8 @@ + (void)readAttributeLifetimeRunningHoursWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
@@ -62944,9 +62441,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -62956,14 +62452,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -62972,27 +62468,25 @@ - (void)subscribeAttributePowerWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63000,7 +62494,8 @@ + (void)readAttributePowerWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
@@ -63009,9 +62504,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -63022,14 +62516,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeLifetimeEnergyConsumedWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -63044,12 +62538,13 @@ - (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -63066,13 +62561,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLifetimeEnergyConsumedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63082,27 +62575,25 @@ - (void)subscribeAttributeLifetimeEnergyConsumedWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLifetimeEnergyConsumedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63111,7 +62602,8 @@ + (void)readAttributeLifetimeEnergyConsumedWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
@@ -63120,9 +62612,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -63132,15 +62623,16 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
-            auto successFn
-                = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
+                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -63155,12 +62647,13 @@ - (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -63172,13 +62665,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63187,30 +62678,29 @@ - (void)subscribeAttributeOperationModeWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63218,8 +62708,9 @@ + (void)readAttributeOperationModeWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
@@ -63228,10 +62719,8 @@ new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridg
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -63241,14 +62730,15 @@ new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridg
 
 - (void)readAttributeControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
-            auto successFn = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -63263,12 +62753,13 @@ - (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -63280,13 +62771,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeControlModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63295,30 +62784,28 @@ - (void)subscribeAttributeControlModeWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63326,8 +62813,9 @@ + (void)readAttributeControlModeWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
@@ -63336,10 +62824,8 @@ new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -63349,15 +62835,16 @@ new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn
-                = Callback<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                PumpConfigurationAndControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
+                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63367,30 +62854,29 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63399,8 +62885,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
@@ -63409,10 +62896,8 @@ new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridg
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -63422,14 +62907,15 @@ new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridg
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63439,30 +62925,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63471,8 +62955,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
@@ -63481,10 +62966,8 @@ new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -63494,14 +62977,15 @@ new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<PumpConfigurationAndControlAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63510,28 +62994,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<PumpConfigurationAndControlAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PumpConfigurationAndControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63539,8 +63023,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PumpConfigurationAndControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
@@ -63549,9 +63034,8 @@ new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PumpConfigurationAndControlAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -63561,14 +63045,14 @@ new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63577,26 +63061,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63604,7 +63087,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
@@ -63613,9 +63097,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -63625,14 +63108,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -63641,26 +63124,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -63668,7 +63150,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
@@ -63677,9 +63160,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -64716,12 +64198,13 @@ - (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Thermostat::Commands::SetpointRaiseLower::Type request;
@@ -64733,23 +64216,23 @@ new MTRCommandSuccessCallbackBridge(
             request.mode = static_cast<std::remove_reference_t<decltype(request.mode)>>(params.mode.unsignedCharValue);
             request.amount = params.amount.charValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Thermostat::Commands::SetWeeklySchedule::Type request;
@@ -64798,11 +64281,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams *)params
@@ -64811,8 +64293,10 @@ - (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatClusterGetWeeklyScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Thermostat::Commands::GetWeeklySchedule::Type request;
@@ -64826,11 +64310,10 @@ new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQue
             request.modeToReturn
                 = static_cast<std::remove_reference_t<decltype(request.modeToReturn)>>(params.modeToReturn.unsignedCharValue);
 
-            auto successFn = Callback<ThermostatClusterGetWeeklyScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)clearWeeklyScheduleWithCompletion:(MTRStatusCompletion)completion
@@ -64842,12 +64325,13 @@ - (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Thermostat::Commands::ClearWeeklySchedule::Type request;
@@ -64857,23 +64341,22 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeLocalTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLocalTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -64882,27 +64365,25 @@ - (void)subscribeAttributeLocalTemperatureWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLocalTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -64910,7 +64391,8 @@ + (void)readAttributeLocalTemperatureWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
@@ -64919,9 +64401,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -64931,14 +64412,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeOutdoorTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOutdoorTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -64948,27 +64429,25 @@ - (void)subscribeAttributeOutdoorTemperatureWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOutdoorTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -64977,7 +64456,8 @@ + (void)readAttributeOutdoorTemperatureWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
@@ -64986,9 +64466,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -64998,14 +64477,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65014,26 +64493,25 @@ - (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65041,7 +64519,8 @@ + (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
@@ -65050,9 +64529,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65063,14 +64541,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeAbsMinHeatSetpointLimitWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAbsMinHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65080,26 +64558,25 @@ - (void)subscribeAttributeAbsMinHeatSetpointLimitWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAbsMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65108,7 +64585,8 @@ + (void)readAttributeAbsMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
@@ -65117,9 +64595,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65130,14 +64607,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAbsMaxHeatSetpointLimitWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAbsMaxHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65147,26 +64624,25 @@ - (void)subscribeAttributeAbsMaxHeatSetpointLimitWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAbsMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65175,7 +64651,8 @@ + (void)readAttributeAbsMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
@@ -65184,9 +64661,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65197,14 +64673,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAbsMinCoolSetpointLimitWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAbsMinCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65214,26 +64690,25 @@ - (void)subscribeAttributeAbsMinCoolSetpointLimitWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAbsMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65242,7 +64717,8 @@ + (void)readAttributeAbsMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
@@ -65251,9 +64727,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65264,14 +64739,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAbsMaxCoolSetpointLimitWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAbsMaxCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65281,26 +64756,25 @@ - (void)subscribeAttributeAbsMaxCoolSetpointLimitWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAbsMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65309,7 +64783,8 @@ + (void)readAttributeAbsMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
@@ -65318,9 +64793,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65330,14 +64804,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePICoolingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePICoolingDemandWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65346,26 +64820,25 @@ - (void)subscribeAttributePICoolingDemandWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePICoolingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65373,7 +64846,8 @@ + (void)readAttributePICoolingDemandWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
@@ -65382,9 +64856,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65394,14 +64867,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributePIHeatingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePIHeatingDemandWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65410,26 +64883,25 @@ - (void)subscribeAttributePIHeatingDemandWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePIHeatingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65437,7 +64909,8 @@ + (void)readAttributePIHeatingDemandWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
@@ -65446,9 +64919,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65459,14 +64931,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeHVACSystemTypeConfigurationWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -65481,12 +64953,13 @@ - (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -65498,13 +64971,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHVACSystemTypeConfigurationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65514,26 +64985,25 @@ - (void)subscribeAttributeHVACSystemTypeConfigurationWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHVACSystemTypeConfigurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65542,7 +65012,8 @@ + (void)readAttributeHVACSystemTypeConfigurationWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
@@ -65551,9 +65022,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65564,14 +65034,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeLocalTemperatureCalibrationWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -65586,12 +65056,13 @@ - (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -65603,13 +65074,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.charValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLocalTemperatureCalibrationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65619,26 +65088,25 @@ - (void)subscribeAttributeLocalTemperatureCalibrationWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLocalTemperatureCalibrationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65647,7 +65115,8 @@ + (void)readAttributeLocalTemperatureCalibrationWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
@@ -65656,9 +65125,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65669,14 +65137,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeOccupiedCoolingSetpointWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -65691,12 +65159,13 @@ - (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -65708,13 +65177,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupiedCoolingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65724,26 +65191,25 @@ - (void)subscribeAttributeOccupiedCoolingSetpointWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65752,7 +65218,8 @@ + (void)readAttributeOccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
@@ -65761,9 +65228,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65774,14 +65240,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeOccupiedHeatingSetpointWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -65796,12 +65262,13 @@ - (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -65813,13 +65280,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupiedHeatingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65829,26 +65294,25 @@ - (void)subscribeAttributeOccupiedHeatingSetpointWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65857,7 +65321,8 @@ + (void)readAttributeOccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
@@ -65866,9 +65331,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65879,14 +65343,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeUnoccupiedCoolingSetpointWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -65901,12 +65365,13 @@ - (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)va
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -65918,13 +65383,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUnoccupiedCoolingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -65934,26 +65397,25 @@ - (void)subscribeAttributeUnoccupiedCoolingSetpointWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUnoccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -65962,7 +65424,8 @@ + (void)readAttributeUnoccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
@@ -65971,9 +65434,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -65984,14 +65446,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeUnoccupiedHeatingSetpointWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66006,12 +65468,13 @@ - (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)va
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66023,13 +65486,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUnoccupiedHeatingSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66039,26 +65500,25 @@ - (void)subscribeAttributeUnoccupiedHeatingSetpointWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUnoccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66067,7 +65527,8 @@ + (void)readAttributeUnoccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
@@ -66076,9 +65537,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66088,14 +65548,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMinHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66110,12 +65570,13 @@ - (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66127,13 +65588,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66143,26 +65602,25 @@ - (void)subscribeAttributeMinHeatSetpointLimitWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66171,7 +65629,8 @@ + (void)readAttributeMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
@@ -66180,9 +65639,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66192,14 +65650,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMaxHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66214,12 +65672,13 @@ - (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66231,13 +65690,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66247,26 +65704,25 @@ - (void)subscribeAttributeMaxHeatSetpointLimitWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66275,7 +65731,8 @@ + (void)readAttributeMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
@@ -66284,9 +65741,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66296,14 +65752,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMinCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66318,12 +65774,13 @@ - (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66335,13 +65792,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66351,26 +65806,25 @@ - (void)subscribeAttributeMinCoolSetpointLimitWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66379,7 +65833,8 @@ + (void)readAttributeMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
@@ -66388,9 +65843,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66400,14 +65854,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMaxCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66422,12 +65876,13 @@ - (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66439,13 +65894,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66455,26 +65908,25 @@ - (void)subscribeAttributeMaxCoolSetpointLimitWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66483,7 +65935,8 @@ + (void)readAttributeMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
@@ -66492,9 +65945,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66504,14 +65956,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeMinSetpointDeadBandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66526,12 +65978,13 @@ - (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66543,13 +65996,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.charValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinSetpointDeadBandWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66559,26 +66010,25 @@ - (void)subscribeAttributeMinSetpointDeadBandWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinSetpointDeadBandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66587,7 +66037,8 @@ + (void)readAttributeMinSetpointDeadBandWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
@@ -66596,9 +66047,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66608,14 +66058,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeRemoteSensingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66630,12 +66080,13 @@ - (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66647,13 +66098,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRemoteSensingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66662,26 +66111,25 @@ - (void)subscribeAttributeRemoteSensingWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRemoteSensingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66689,7 +66137,8 @@ + (void)readAttributeRemoteSensingWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
@@ -66698,9 +66147,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66711,14 +66159,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeControlSequenceOfOperationWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatClusterThermostatControlSequenceAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
-            auto successFn = Callback<ThermostatClusterThermostatControlSequenceAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66733,12 +66182,13 @@ - (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)v
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66750,13 +66200,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeControlSequenceOfOperationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66766,28 +66214,28 @@ - (void)subscribeAttributeControlSequenceOfOperationWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
-                auto successFn = Callback<ThermostatClusterThermostatControlSequenceAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatClusterThermostatControlSequenceAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeControlSequenceOfOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66796,8 +66244,9 @@ + (void)readAttributeControlSequenceOfOperationWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThermostatClusterThermostatControlSequenceAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
@@ -66806,9 +66255,8 @@ new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThermostatClusterThermostatControlSequenceAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -66818,14 +66266,14 @@ new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(
 
 - (void)readAttributeSystemModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -66840,12 +66288,13 @@ - (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -66857,13 +66306,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSystemModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66872,26 +66319,25 @@ - (void)subscribeAttributeSystemModeWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSystemModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66899,7 +66345,8 @@ + (void)readAttributeSystemModeWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
@@ -66908,9 +66355,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66920,14 +66366,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeThermostatRunningModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeThermostatRunningModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -66937,26 +66383,25 @@ - (void)subscribeAttributeThermostatRunningModeWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeThermostatRunningModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -66965,7 +66410,8 @@ + (void)readAttributeThermostatRunningModeWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
@@ -66974,9 +66420,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -66986,14 +66431,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeStartOfWeekWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStartOfWeekWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67002,26 +66447,25 @@ - (void)subscribeAttributeStartOfWeekWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStartOfWeekWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67029,7 +66473,8 @@ + (void)readAttributeStartOfWeekWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
@@ -67038,9 +66483,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67051,14 +66495,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeNumberOfWeeklyTransitionsWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfWeeklyTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67068,26 +66512,25 @@ - (void)subscribeAttributeNumberOfWeeklyTransitionsWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfWeeklyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67096,7 +66539,8 @@ + (void)readAttributeNumberOfWeeklyTransitionsWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
@@ -67105,9 +66549,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67118,14 +66561,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeNumberOfDailyTransitionsWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfDailyTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67135,26 +66578,25 @@ - (void)subscribeAttributeNumberOfDailyTransitionsWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfDailyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67163,7 +66605,8 @@ + (void)readAttributeNumberOfDailyTransitionsWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
@@ -67172,9 +66615,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67185,14 +66627,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeTemperatureSetpointHoldWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -67207,12 +66649,13 @@ - (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -67224,13 +66667,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTemperatureSetpointHoldWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67240,26 +66681,25 @@ - (void)subscribeAttributeTemperatureSetpointHoldWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTemperatureSetpointHoldWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67268,7 +66708,8 @@ + (void)readAttributeTemperatureSetpointHoldWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
@@ -67277,9 +66718,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67290,14 +66730,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeTemperatureSetpointHoldDurationWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Nullable)value
@@ -67313,12 +66753,13 @@ - (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Null
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -67335,13 +66776,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTemperatureSetpointHoldDurationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67352,27 +66791,25 @@ - (void)subscribeAttributeTemperatureSetpointHoldDurationWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTemperatureSetpointHoldDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67381,7 +66818,8 @@ + (void)readAttributeTemperatureSetpointHoldDurationWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
@@ -67390,9 +66828,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67403,14 +66840,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeThermostatProgrammingOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _Nonnull)value
@@ -67426,12 +66863,13 @@ - (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _N
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -67443,13 +66881,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeThermostatProgrammingOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67460,26 +66896,25 @@ - (void)subscribeAttributeThermostatProgrammingOperationModeWithParams:(MTRSubsc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeThermostatProgrammingOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67488,7 +66923,8 @@ + (void)readAttributeThermostatProgrammingOperationModeWithAttributeCache:(MTRAt
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
@@ -67497,9 +66933,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67510,14 +66945,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeThermostatRunningStateWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeThermostatRunningStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67527,26 +66962,25 @@ - (void)subscribeAttributeThermostatRunningStateWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeThermostatRunningStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67555,7 +66989,8 @@ + (void)readAttributeThermostatRunningStateWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
@@ -67564,9 +66999,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67576,14 +67010,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeSetpointChangeSourceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSetpointChangeSourceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67593,26 +67027,25 @@ - (void)subscribeAttributeSetpointChangeSourceWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSetpointChangeSourceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67621,7 +67054,8 @@ + (void)readAttributeSetpointChangeSourceWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
@@ -67630,9 +67064,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67642,14 +67075,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeSetpointChangeAmountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSetpointChangeAmountWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67659,27 +67092,25 @@ - (void)subscribeAttributeSetpointChangeAmountWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSetpointChangeAmountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67688,7 +67119,8 @@ + (void)readAttributeSetpointChangeAmountWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
@@ -67697,9 +67129,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67710,14 +67141,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeSetpointChangeSourceTimestampWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSetpointChangeSourceTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67728,26 +67159,25 @@ - (void)subscribeAttributeSetpointChangeSourceTimestampWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSetpointChangeSourceTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67756,7 +67186,8 @@ + (void)readAttributeSetpointChangeSourceTimestampWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
@@ -67765,9 +67196,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67777,14 +67207,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -67799,12 +67229,13 @@ - (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -67821,13 +67252,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupiedSetbackWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67836,27 +67265,25 @@ - (void)subscribeAttributeOccupiedSetbackWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67864,7 +67291,8 @@ + (void)readAttributeOccupiedSetbackWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
@@ -67873,9 +67301,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67885,14 +67312,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeOccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupiedSetbackMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67902,27 +67329,25 @@ - (void)subscribeAttributeOccupiedSetbackMinWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67931,7 +67356,8 @@ + (void)readAttributeOccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
@@ -67940,9 +67366,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -67952,14 +67377,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeOccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupiedSetbackMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -67969,27 +67394,25 @@ - (void)subscribeAttributeOccupiedSetbackMaxWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -67998,7 +67421,8 @@ + (void)readAttributeOccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
@@ -68007,9 +67431,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68019,14 +67442,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeUnoccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -68041,12 +67464,13 @@ - (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68063,13 +67487,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUnoccupiedSetbackWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68078,27 +67500,25 @@ - (void)subscribeAttributeUnoccupiedSetbackWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUnoccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68106,7 +67526,8 @@ + (void)readAttributeUnoccupiedSetbackWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
@@ -68115,9 +67536,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68127,14 +67547,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeUnoccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUnoccupiedSetbackMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68144,27 +67564,25 @@ - (void)subscribeAttributeUnoccupiedSetbackMinWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUnoccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68173,7 +67591,8 @@ + (void)readAttributeUnoccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
@@ -68182,9 +67601,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68194,14 +67612,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeUnoccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUnoccupiedSetbackMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68211,27 +67629,25 @@ - (void)subscribeAttributeUnoccupiedSetbackMaxWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUnoccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68240,7 +67656,8 @@ + (void)readAttributeUnoccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
@@ -68249,9 +67666,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68261,14 +67677,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeEmergencyHeatDeltaWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68283,12 +67699,13 @@ - (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68300,13 +67717,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEmergencyHeatDeltaWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68316,26 +67731,25 @@ - (void)subscribeAttributeEmergencyHeatDeltaWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEmergencyHeatDeltaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68344,7 +67758,8 @@ + (void)readAttributeEmergencyHeatDeltaWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
@@ -68353,9 +67768,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68365,14 +67779,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeACTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68387,12 +67801,13 @@ - (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68404,13 +67819,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68419,26 +67832,25 @@ - (void)subscribeAttributeACTypeWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68446,7 +67858,8 @@ + (void)readAttributeACTypeWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
@@ -68455,9 +67868,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68467,14 +67879,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeACCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68489,12 +67901,13 @@ - (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68506,13 +67919,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68521,26 +67932,25 @@ - (void)subscribeAttributeACCapacityWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68548,7 +67958,8 @@ + (void)readAttributeACCapacityWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
@@ -68557,9 +67968,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68569,14 +67979,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeACRefrigerantTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68591,12 +68001,13 @@ - (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68608,13 +68019,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACRefrigerantTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68623,26 +68032,25 @@ - (void)subscribeAttributeACRefrigerantTypeWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACRefrigerantTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68650,7 +68058,8 @@ + (void)readAttributeACRefrigerantTypeWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
@@ -68659,9 +68068,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68671,14 +68079,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeACCompressorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68693,12 +68101,13 @@ - (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68710,13 +68119,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACCompressorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68725,26 +68132,25 @@ - (void)subscribeAttributeACCompressorTypeWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACCompressorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68752,7 +68158,8 @@ + (void)readAttributeACCompressorTypeWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
@@ -68761,9 +68168,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68773,14 +68179,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeACErrorCodeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68795,12 +68201,13 @@ - (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68812,13 +68219,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACErrorCodeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68827,26 +68232,25 @@ - (void)subscribeAttributeACErrorCodeWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACErrorCodeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68854,7 +68258,8 @@ + (void)readAttributeACErrorCodeWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
@@ -68863,9 +68268,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68875,14 +68279,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeACLouverPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -68897,12 +68301,13 @@ - (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -68914,13 +68319,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACLouverPositionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68929,26 +68332,25 @@ - (void)subscribeAttributeACLouverPositionWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACLouverPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -68956,7 +68358,8 @@ + (void)readAttributeACLouverPositionWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
@@ -68965,9 +68368,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -68977,14 +68379,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeACCoilTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACCoilTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -68993,27 +68395,25 @@ - (void)subscribeAttributeACCoilTemperatureWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACCoilTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69021,7 +68421,8 @@ + (void)readAttributeACCoilTemperatureWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
@@ -69030,9 +68431,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -69042,14 +68442,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeACCapacityformatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -69064,12 +68464,13 @@ - (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -69081,13 +68482,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeACCapacityformatWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -69096,26 +68495,25 @@ - (void)subscribeAttributeACCapacityformatWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeACCapacityformatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69123,7 +68521,8 @@ + (void)readAttributeACCapacityformatWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
@@ -69132,9 +68531,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -69144,14 +68542,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ThermostatGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -69161,27 +68560,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ThermostatGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69190,8 +68589,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThermostatGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
@@ -69200,9 +68600,8 @@ new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThermostatGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -69212,14 +68611,15 @@ new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ThermostatAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -69229,27 +68629,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ThermostatAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69258,8 +68658,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThermostatAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
@@ -69268,9 +68669,8 @@ new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ThermostatAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -69280,14 +68680,14 @@ new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ThermostatAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ThermostatAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -69296,27 +68696,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ThermostatAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ThermostatAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69324,7 +68723,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ThermostatAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
@@ -69333,9 +68733,8 @@ new MTRThermostatAttributeListListAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ThermostatAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -69345,14 +68744,14 @@ new MTRThermostatAttributeListListAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -69361,26 +68760,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69388,7 +68786,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
@@ -69397,9 +68796,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -69409,14 +68807,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -69425,26 +68823,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -69452,7 +68849,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
@@ -69461,9 +68859,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -71722,14 +71119,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeFanModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlClusterFanModeTypeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
-            auto successFn = Callback<FanControlClusterFanModeTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -71744,12 +71141,13 @@ - (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -71761,13 +71159,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFanModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -71776,27 +71172,26 @@ - (void)subscribeAttributeFanModeWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
-                auto successFn = Callback<FanControlClusterFanModeTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlClusterFanModeTypeAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFanModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -71804,7 +71199,8 @@ + (void)readAttributeFanModeWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(FanControlClusterFanModeTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
@@ -71813,9 +71209,8 @@ new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<FanControlClusterFanModeTypeAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -71825,14 +71220,15 @@ new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeFanModeSequenceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FanControlClusterFanModeSequenceTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
-            auto successFn = Callback<FanControlClusterFanModeSequenceTypeAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -71847,12 +71243,13 @@ - (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -71864,13 +71261,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFanModeSequenceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -71879,27 +71274,27 @@ - (void)subscribeAttributeFanModeSequenceWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
-                auto successFn = Callback<FanControlClusterFanModeSequenceTypeAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FanControlClusterFanModeSequenceTypeAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFanModeSequenceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -71907,8 +71302,9 @@ + (void)readAttributeFanModeSequenceWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FanControlClusterFanModeSequenceTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
@@ -71917,9 +71313,8 @@ new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FanControlClusterFanModeSequenceTypeAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -71929,14 +71324,14 @@ new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(
 
 - (void)readAttributePercentSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -71951,12 +71346,13 @@ - (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -71973,13 +71369,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePercentSettingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -71988,27 +71382,25 @@ - (void)subscribeAttributePercentSettingWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePercentSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72016,7 +71408,8 @@ + (void)readAttributePercentSettingWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
@@ -72025,9 +71418,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72037,14 +71429,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePercentCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePercentCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72053,26 +71445,25 @@ - (void)subscribeAttributePercentCurrentWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePercentCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72080,7 +71471,8 @@ + (void)readAttributePercentCurrentWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
@@ -72089,9 +71481,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72101,14 +71492,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeSpeedMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSpeedMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72117,26 +71508,25 @@ - (void)subscribeAttributeSpeedMaxWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSpeedMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72144,7 +71534,8 @@ + (void)readAttributeSpeedMaxWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
@@ -72153,9 +71544,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72165,14 +71555,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeSpeedSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -72187,12 +71577,13 @@ - (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -72209,13 +71600,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSpeedSettingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72224,27 +71613,25 @@ - (void)subscribeAttributeSpeedSettingWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSpeedSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72252,7 +71639,8 @@ + (void)readAttributeSpeedSettingWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
@@ -72261,9 +71649,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72273,14 +71660,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeSpeedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSpeedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72289,26 +71676,25 @@ - (void)subscribeAttributeSpeedCurrentWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSpeedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72316,7 +71702,8 @@ + (void)readAttributeSpeedCurrentWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
@@ -72325,9 +71712,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72337,14 +71723,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeRockSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRockSupportWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72353,26 +71739,25 @@ - (void)subscribeAttributeRockSupportWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRockSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72380,7 +71765,8 @@ + (void)readAttributeRockSupportWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
@@ -72389,9 +71775,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72401,14 +71786,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeRockSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -72423,12 +71808,13 @@ - (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -72440,13 +71826,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRockSettingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72455,26 +71839,25 @@ - (void)subscribeAttributeRockSettingWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRockSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72482,7 +71865,8 @@ + (void)readAttributeRockSettingWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
@@ -72491,9 +71875,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72503,14 +71886,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeWindSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWindSupportWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72519,26 +71902,25 @@ - (void)subscribeAttributeWindSupportWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWindSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72546,7 +71928,8 @@ + (void)readAttributeWindSupportWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
@@ -72555,9 +71938,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72567,14 +71949,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeWindSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -72589,12 +71971,13 @@ - (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -72606,13 +71989,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWindSettingWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72621,26 +72002,25 @@ - (void)subscribeAttributeWindSettingWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWindSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72648,7 +72028,8 @@ + (void)readAttributeWindSettingWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
@@ -72657,9 +72038,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72669,14 +72049,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FanControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<FanControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72686,27 +72067,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<FanControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FanControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72715,8 +72096,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FanControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
@@ -72725,9 +72107,8 @@ new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FanControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -72737,14 +72118,15 @@ new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FanControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<FanControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72754,27 +72136,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<FanControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FanControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72783,8 +72165,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FanControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
@@ -72793,9 +72176,8 @@ new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FanControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -72805,14 +72187,14 @@ new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<FanControlAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72821,27 +72203,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<FanControlAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72849,7 +72230,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFanControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFanControlAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(FanControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
@@ -72858,9 +72240,8 @@ new MTRFanControlAttributeListListAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<FanControlAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72870,14 +72251,14 @@ new MTRFanControlAttributeListListAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72886,26 +72267,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72913,7 +72293,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
@@ -72922,9 +72303,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -72934,14 +72314,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -72950,26 +72330,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -72977,7 +72356,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
@@ -72986,9 +72366,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -73633,14 +73012,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 - (void)readAttributeTemperatureDisplayModeWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -73655,12 +73034,13 @@ - (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -73672,13 +73052,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTemperatureDisplayModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -73688,26 +73066,25 @@ - (void)subscribeAttributeTemperatureDisplayModeWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTemperatureDisplayModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -73716,7 +73093,8 @@ + (void)readAttributeTemperatureDisplayModeWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
@@ -73725,9 +73103,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -73737,14 +73114,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeKeypadLockoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -73759,12 +73136,13 @@ - (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -73776,13 +73154,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeKeypadLockoutWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -73791,26 +73167,25 @@ - (void)subscribeAttributeKeypadLockoutWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeKeypadLockoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -73818,7 +73193,8 @@ + (void)readAttributeKeypadLockoutWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
@@ -73827,9 +73203,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -73840,14 +73215,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeScheduleProgrammingVisibilityWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -73862,12 +73237,13 @@ - (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnul
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -73879,13 +73255,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeScheduleProgrammingVisibilityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -73896,26 +73270,25 @@ - (void)subscribeAttributeScheduleProgrammingVisibilityWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeScheduleProgrammingVisibilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -73924,7 +73297,8 @@ + (void)readAttributeScheduleProgrammingVisibilityWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
@@ -73933,9 +73307,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -73945,16 +73318,16 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device,
-        completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn
-                = Callback<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
+                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -73964,32 +73337,30 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(
-                        success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(
+                    bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *
-                    innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -73998,8 +73369,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
@@ -74008,11 +73380,8 @@ new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCall
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(
-                        success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -74022,16 +73391,16 @@ new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCall
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device,
-        completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn
-                = Callback<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
+                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -74041,32 +73410,30 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(
-                        success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(
+                    bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *
-                    innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -74075,8 +73442,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
@@ -74085,11 +73453,8 @@ new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallb
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(
-                        success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -74099,15 +73464,16 @@ new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallb
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
-            auto successFn
-                = Callback<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
+                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -74116,30 +73482,30 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
-                auto successFn
-                    = Callback<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(
+                    bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -74147,8 +73513,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
@@ -74157,10 +73524,8 @@ new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBri
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -74170,14 +73535,14 @@ new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBri
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -74186,26 +73551,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -74213,7 +73577,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
@@ -74222,9 +73587,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -74234,14 +73598,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -74250,26 +73614,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -74277,7 +73640,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
@@ -74286,9 +73650,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -74639,12 +74002,13 @@ - (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params comp
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveToHue::Type request;
@@ -74660,23 +74024,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveHue::Type request;
@@ -74690,23 +74054,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::StepHue::Type request;
@@ -74721,23 +74085,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveToSaturation::Type request;
@@ -74751,23 +74115,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveSaturation::Type request;
@@ -74781,23 +74145,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::StepSaturation::Type request;
@@ -74812,11 +74176,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params
@@ -74824,12 +74187,13 @@ - (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSatu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveToHueAndSaturation::Type request;
@@ -74844,23 +74208,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveToColor::Type request;
@@ -74875,23 +74239,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveColor::Type request;
@@ -74905,23 +74269,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::StepColor::Type request;
@@ -74936,11 +74300,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params
@@ -74948,12 +74311,13 @@ - (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTempe
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveToColorTemperature::Type request;
@@ -74967,11 +74331,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params
@@ -74979,12 +74342,13 @@ - (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHuePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::EnhancedMoveToHue::Type request;
@@ -75000,23 +74364,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::EnhancedMoveHue::Type request;
@@ -75030,23 +74394,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::EnhancedStepHue::Type request;
@@ -75061,11 +74425,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params
@@ -75073,12 +74436,13 @@ - (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhanced
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type request;
@@ -75093,23 +74457,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::ColorLoopSet::Type request;
@@ -75128,23 +74492,23 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::StopMoveStep::Type request;
@@ -75156,11 +74520,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params
@@ -75168,12 +74531,13 @@ - (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::MoveColorTemperature::Type request;
@@ -75189,11 +74553,10 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params
@@ -75201,12 +74564,13 @@ - (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ColorControl::Commands::StepColorTemperature::Type request;
@@ -75223,23 +74587,22 @@ new MTRCommandSuccessCallbackBridge(
             request.optionsMask = params.optionsMask.unsignedCharValue;
             request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75248,26 +74611,25 @@ - (void)subscribeAttributeCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75275,7 +74637,8 @@ + (void)readAttributeCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
@@ -75284,9 +74647,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75296,14 +74658,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCurrentSaturationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentSaturationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75312,26 +74674,25 @@ - (void)subscribeAttributeCurrentSaturationWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentSaturationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75339,7 +74700,8 @@ + (void)readAttributeCurrentSaturationWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
@@ -75348,9 +74710,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75360,14 +74721,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75376,26 +74737,25 @@ - (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75403,7 +74763,8 @@ + (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
@@ -75412,9 +74773,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75424,14 +74784,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCurrentXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentXWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75440,26 +74800,25 @@ - (void)subscribeAttributeCurrentXWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75467,7 +74826,8 @@ + (void)readAttributeCurrentXWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
@@ -75476,9 +74836,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75488,14 +74847,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCurrentYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentYWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75504,26 +74863,25 @@ - (void)subscribeAttributeCurrentYWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75531,7 +74889,8 @@ + (void)readAttributeCurrentYWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
@@ -75540,9 +74899,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75552,14 +74910,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDriftCompensationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDriftCompensationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75568,26 +74926,25 @@ - (void)subscribeAttributeDriftCompensationWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDriftCompensationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75595,7 +74952,8 @@ + (void)readAttributeDriftCompensationWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
@@ -75604,9 +74962,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75616,14 +74973,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeCompensationTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCompensationTextWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75632,27 +74989,25 @@ - (void)subscribeAttributeCompensationTextWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCompensationTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75660,7 +75015,8 @@ + (void)readAttributeCompensationTextWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
@@ -75669,9 +75025,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75682,14 +75037,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 - (void)readAttributeColorTemperatureMiredsWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorTemperatureMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75699,26 +75054,25 @@ - (void)subscribeAttributeColorTemperatureMiredsWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75727,7 +75081,8 @@ + (void)readAttributeColorTemperatureMiredsWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
@@ -75736,9 +75091,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75748,14 +75102,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75764,26 +75118,25 @@ - (void)subscribeAttributeColorModeWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75791,7 +75144,8 @@ + (void)readAttributeColorModeWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
@@ -75800,9 +75154,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75812,14 +75165,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -75834,12 +75187,13 @@ - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -75851,13 +75205,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOptionsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75866,26 +75218,25 @@ - (void)subscribeAttributeOptionsWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75893,7 +75244,8 @@ + (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
@@ -75902,9 +75254,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75914,14 +75265,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeNumberOfPrimariesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNumberOfPrimariesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75930,27 +75281,25 @@ - (void)subscribeAttributeNumberOfPrimariesWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNumberOfPrimariesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -75958,7 +75307,8 @@ + (void)readAttributeNumberOfPrimariesWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
@@ -75967,9 +75317,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -75979,14 +75328,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePrimary1XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary1XWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -75995,26 +75344,25 @@ - (void)subscribeAttributePrimary1XWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary1XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76022,7 +75370,8 @@ + (void)readAttributePrimary1XWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
@@ -76031,9 +75380,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76043,14 +75391,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary1YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary1YWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76059,26 +75407,25 @@ - (void)subscribeAttributePrimary1YWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary1YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76086,7 +75433,8 @@ + (void)readAttributePrimary1YWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
@@ -76095,9 +75443,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76107,14 +75454,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary1IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary1IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76123,27 +75470,25 @@ - (void)subscribeAttributePrimary1IntensityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary1IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76151,7 +75496,8 @@ + (void)readAttributePrimary1IntensityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
@@ -76160,9 +75506,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76172,14 +75517,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePrimary2XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary2XWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76188,26 +75533,25 @@ - (void)subscribeAttributePrimary2XWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary2XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76215,7 +75559,8 @@ + (void)readAttributePrimary2XWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
@@ -76224,9 +75569,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76236,14 +75580,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary2YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary2YWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76252,26 +75596,25 @@ - (void)subscribeAttributePrimary2YWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary2YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76279,7 +75622,8 @@ + (void)readAttributePrimary2YWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
@@ -76288,9 +75632,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76300,14 +75643,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary2IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary2IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76316,27 +75659,25 @@ - (void)subscribeAttributePrimary2IntensityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary2IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76344,7 +75685,8 @@ + (void)readAttributePrimary2IntensityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
@@ -76353,9 +75695,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76365,14 +75706,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePrimary3XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary3XWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76381,26 +75722,25 @@ - (void)subscribeAttributePrimary3XWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary3XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76408,7 +75748,8 @@ + (void)readAttributePrimary3XWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
@@ -76417,9 +75758,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76429,14 +75769,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary3YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary3YWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76445,26 +75785,25 @@ - (void)subscribeAttributePrimary3YWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary3YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76472,7 +75811,8 @@ + (void)readAttributePrimary3YWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
@@ -76481,9 +75821,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76493,14 +75832,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary3IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary3IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76509,27 +75848,25 @@ - (void)subscribeAttributePrimary3IntensityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary3IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76537,7 +75874,8 @@ + (void)readAttributePrimary3IntensityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
@@ -76546,9 +75884,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76558,14 +75895,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePrimary4XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary4XWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76574,26 +75911,25 @@ - (void)subscribeAttributePrimary4XWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary4XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76601,7 +75937,8 @@ + (void)readAttributePrimary4XWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
@@ -76610,9 +75947,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76622,14 +75958,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary4YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary4YWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76638,26 +75974,25 @@ - (void)subscribeAttributePrimary4YWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary4YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76665,7 +76000,8 @@ + (void)readAttributePrimary4YWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
@@ -76674,9 +76010,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76686,14 +76021,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary4IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary4IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76702,27 +76037,25 @@ - (void)subscribeAttributePrimary4IntensityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary4IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76730,7 +76063,8 @@ + (void)readAttributePrimary4IntensityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
@@ -76739,9 +76073,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76751,14 +76084,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePrimary5XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary5XWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76767,26 +76100,25 @@ - (void)subscribeAttributePrimary5XWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary5XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76794,7 +76126,8 @@ + (void)readAttributePrimary5XWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
@@ -76803,9 +76136,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76815,14 +76147,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary5YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary5YWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76831,26 +76163,25 @@ - (void)subscribeAttributePrimary5YWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary5YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76858,7 +76189,8 @@ + (void)readAttributePrimary5YWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
@@ -76867,9 +76199,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76879,14 +76210,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary5IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary5IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76895,27 +76226,25 @@ - (void)subscribeAttributePrimary5IntensityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary5IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76923,7 +76252,8 @@ + (void)readAttributePrimary5IntensityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
@@ -76932,9 +76262,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -76944,14 +76273,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributePrimary6XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary6XWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -76960,26 +76289,25 @@ - (void)subscribeAttributePrimary6XWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary6XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -76987,7 +76315,8 @@ + (void)readAttributePrimary6XWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
@@ -76996,9 +76325,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77008,14 +76336,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary6YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary6YWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77024,26 +76352,25 @@ - (void)subscribeAttributePrimary6YWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary6YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77051,7 +76378,8 @@ + (void)readAttributePrimary6YWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
@@ -77060,9 +76388,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77072,14 +76399,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePrimary6IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePrimary6IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77088,27 +76415,25 @@ - (void)subscribeAttributePrimary6IntensityWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePrimary6IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77116,7 +76441,8 @@ + (void)readAttributePrimary6IntensityWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
@@ -77125,9 +76451,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77137,14 +76462,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeWhitePointXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77159,12 +76484,13 @@ - (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77176,13 +76502,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWhitePointXWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77191,26 +76515,25 @@ - (void)subscribeAttributeWhitePointXWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWhitePointXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77218,7 +76541,8 @@ + (void)readAttributeWhitePointXWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
@@ -77227,9 +76551,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77239,14 +76562,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeWhitePointYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77261,12 +76584,13 @@ - (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77278,13 +76602,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWhitePointYWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77293,26 +76615,25 @@ - (void)subscribeAttributeWhitePointYWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWhitePointYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77320,7 +76641,8 @@ + (void)readAttributeWhitePointYWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
@@ -77329,9 +76651,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77341,14 +76662,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointRXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77363,12 +76684,13 @@ - (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77380,13 +76702,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointRXWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77395,26 +76715,25 @@ - (void)subscribeAttributeColorPointRXWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointRXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77422,7 +76741,8 @@ + (void)readAttributeColorPointRXWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
@@ -77431,9 +76751,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77443,14 +76762,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointRYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77465,12 +76784,13 @@ - (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77482,13 +76802,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointRYWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77497,26 +76815,25 @@ - (void)subscribeAttributeColorPointRYWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointRYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77524,7 +76841,8 @@ + (void)readAttributeColorPointRYWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
@@ -77533,9 +76851,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77545,14 +76862,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointRIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -77567,12 +76884,13 @@ - (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77589,13 +76907,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointRIntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77605,27 +76921,25 @@ - (void)subscribeAttributeColorPointRIntensityWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointRIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77634,7 +76948,8 @@ + (void)readAttributeColorPointRIntensityWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
@@ -77643,9 +76958,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77655,14 +76969,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeColorPointGXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77677,12 +76991,13 @@ - (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77694,13 +77009,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointGXWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77709,26 +77022,25 @@ - (void)subscribeAttributeColorPointGXWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointGXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77736,7 +77048,8 @@ + (void)readAttributeColorPointGXWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
@@ -77745,9 +77058,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77757,14 +77069,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointGYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77779,12 +77091,13 @@ - (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77796,13 +77109,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointGYWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77811,26 +77122,25 @@ - (void)subscribeAttributeColorPointGYWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointGYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77838,7 +77148,8 @@ + (void)readAttributeColorPointGYWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
@@ -77847,9 +77158,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77859,14 +77169,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointGIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -77881,12 +77191,13 @@ - (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -77903,13 +77214,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointGIntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -77919,27 +77228,25 @@ - (void)subscribeAttributeColorPointGIntensityWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointGIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -77948,7 +77255,8 @@ + (void)readAttributeColorPointGIntensityWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
@@ -77957,9 +77265,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -77969,14 +77276,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeColorPointBXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -77991,12 +77298,13 @@ - (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -78008,13 +77316,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointBXWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78023,26 +77329,25 @@ - (void)subscribeAttributeColorPointBXWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointBXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78050,7 +77355,8 @@ + (void)readAttributeColorPointBXWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
@@ -78059,9 +77365,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78071,14 +77376,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointBYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -78093,12 +77398,13 @@ - (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -78110,13 +77416,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointBYWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78125,26 +77429,25 @@ - (void)subscribeAttributeColorPointBYWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointBYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78152,7 +77455,8 @@ + (void)readAttributeColorPointBYWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
@@ -78161,9 +77465,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78173,14 +77476,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorPointBIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -78195,12 +77498,13 @@ - (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -78217,13 +77521,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorPointBIntensityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78233,27 +77535,25 @@ - (void)subscribeAttributeColorPointBIntensityWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorPointBIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78262,7 +77562,8 @@ + (void)readAttributeColorPointBIntensityWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
@@ -78271,9 +77572,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78283,14 +77583,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeEnhancedCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnhancedCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78300,26 +77600,25 @@ - (void)subscribeAttributeEnhancedCurrentHueWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnhancedCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78328,7 +77627,8 @@ + (void)readAttributeEnhancedCurrentHueWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
@@ -78337,9 +77637,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78349,14 +77648,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeEnhancedColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnhancedColorModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78365,26 +77664,25 @@ - (void)subscribeAttributeEnhancedColorModeWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnhancedColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78392,7 +77690,8 @@ + (void)readAttributeEnhancedColorModeWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
@@ -78401,9 +77700,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78413,14 +77711,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeColorLoopActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorLoopActiveWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78429,26 +77727,25 @@ - (void)subscribeAttributeColorLoopActiveWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorLoopActiveWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78456,7 +77753,8 @@ + (void)readAttributeColorLoopActiveWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
@@ -78465,9 +77763,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78477,14 +77774,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeColorLoopDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorLoopDirectionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78494,26 +77791,25 @@ - (void)subscribeAttributeColorLoopDirectionWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorLoopDirectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78522,7 +77818,8 @@ + (void)readAttributeColorLoopDirectionWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
@@ -78531,9 +77828,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78543,14 +77839,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeColorLoopTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorLoopTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78559,26 +77855,25 @@ - (void)subscribeAttributeColorLoopTimeWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorLoopTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78586,7 +77881,8 @@ + (void)readAttributeColorLoopTimeWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
@@ -78595,9 +77891,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78608,14 +77903,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeColorLoopStartEnhancedHueWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorLoopStartEnhancedHueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78625,26 +77920,25 @@ - (void)subscribeAttributeColorLoopStartEnhancedHueWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorLoopStartEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78653,7 +77947,8 @@ + (void)readAttributeColorLoopStartEnhancedHueWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
@@ -78662,9 +77957,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78675,14 +77969,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeColorLoopStoredEnhancedHueWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorLoopStoredEnhancedHueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78692,26 +77986,25 @@ - (void)subscribeAttributeColorLoopStoredEnhancedHueWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorLoopStoredEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78720,7 +78013,8 @@ + (void)readAttributeColorLoopStoredEnhancedHueWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
@@ -78729,9 +78023,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78741,14 +78034,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeColorCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorCapabilitiesWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78757,26 +78050,25 @@ - (void)subscribeAttributeColorCapabilitiesWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78784,7 +78076,8 @@ + (void)readAttributeColorCapabilitiesWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
@@ -78793,9 +78086,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78806,14 +78098,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeColorTempPhysicalMinMiredsWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorTempPhysicalMinMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78823,26 +78115,25 @@ - (void)subscribeAttributeColorTempPhysicalMinMiredsWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorTempPhysicalMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78851,7 +78142,8 @@ + (void)readAttributeColorTempPhysicalMinMiredsWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
@@ -78860,9 +78152,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78873,14 +78164,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeColorTempPhysicalMaxMiredsWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeColorTempPhysicalMaxMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78890,26 +78181,25 @@ - (void)subscribeAttributeColorTempPhysicalMaxMiredsWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeColorTempPhysicalMaxMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78918,7 +78208,8 @@ + (void)readAttributeColorTempPhysicalMaxMiredsWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
@@ -78927,9 +78218,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -78940,14 +78230,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -78958,26 +78248,25 @@ - (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCoupleColorTempToLevelMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -78986,7 +78275,8 @@ + (void)readAttributeCoupleColorTempToLevelMinMiredsWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
@@ -78995,9 +78285,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -79008,14 +78297,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeStartUpColorTemperatureMiredsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -79030,12 +78319,13 @@ - (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullab
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -79052,13 +78342,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStartUpColorTemperatureMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -79069,27 +78357,25 @@ - (void)subscribeAttributeStartUpColorTemperatureMiredsWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStartUpColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -79098,7 +78384,8 @@ + (void)readAttributeStartUpColorTemperatureMiredsWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
@@ -79107,9 +78394,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -79119,14 +78405,15 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ColorControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ColorControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -79136,27 +78423,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ColorControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ColorControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -79165,8 +78452,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ColorControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
@@ -79175,9 +78463,8 @@ new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ColorControlGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -79187,14 +78474,15 @@ new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ColorControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ColorControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -79204,27 +78492,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ColorControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ColorControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -79233,8 +78521,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ColorControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
@@ -79243,9 +78532,8 @@ new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ColorControlAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -79255,14 +78543,14 @@ new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRColorControlAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRColorControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ColorControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ColorControlAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -79271,27 +78559,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ColorControlAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ColorControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -79299,7 +78586,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRColorControlAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRColorControlAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ColorControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
@@ -79308,9 +78596,8 @@ new MTRColorControlAttributeListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ColorControlAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -79320,14 +78607,14 @@ new MTRColorControlAttributeListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -79336,26 +78623,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -79363,7 +78649,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
@@ -79372,9 +78659,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -79384,14 +78670,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -79400,26 +78686,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -79427,7 +78712,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
@@ -79436,9 +78722,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -81673,14 +80958,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributePhysicalMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -81689,26 +80974,25 @@ - (void)subscribeAttributePhysicalMinLevelWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -81716,7 +81000,8 @@ + (void)readAttributePhysicalMinLevelWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
@@ -81725,9 +81010,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -81737,14 +81021,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributePhysicalMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -81753,26 +81037,25 @@ - (void)subscribeAttributePhysicalMaxLevelWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -81780,7 +81063,8 @@ + (void)readAttributePhysicalMaxLevelWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
@@ -81789,9 +81073,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -81801,14 +81084,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeBallastStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBallastStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -81817,26 +81100,25 @@ - (void)subscribeAttributeBallastStatusWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBallastStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -81844,7 +81126,8 @@ + (void)readAttributeBallastStatusWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
@@ -81853,9 +81136,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -81865,14 +81147,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -81887,12 +81169,13 @@ - (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -81904,13 +81187,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -81919,26 +81200,25 @@ - (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -81946,7 +81226,8 @@ + (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
@@ -81955,9 +81236,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -81967,14 +81247,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -81989,12 +81269,13 @@ - (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82006,13 +81287,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82021,26 +81300,25 @@ - (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82048,7 +81326,8 @@ + (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
@@ -82057,9 +81336,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82070,14 +81348,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeIntrinsicBalanceFactorWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -82092,12 +81370,13 @@ - (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82114,13 +81393,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeIntrinsicBalanceFactorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82130,27 +81407,25 @@ - (void)subscribeAttributeIntrinsicBalanceFactorWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeIntrinsicBalanceFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82159,7 +81434,8 @@ + (void)readAttributeIntrinsicBalanceFactorWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
@@ -82168,9 +81444,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82181,14 +81456,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 - (void)readAttributeBallastFactorAdjustmentWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -82203,12 +81478,13 @@ - (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)val
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82225,13 +81501,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBallastFactorAdjustmentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82241,27 +81515,25 @@ - (void)subscribeAttributeBallastFactorAdjustmentWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBallastFactorAdjustmentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82270,7 +81542,8 @@ + (void)readAttributeBallastFactorAdjustmentWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
@@ -82279,9 +81552,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82291,14 +81563,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeLampQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampQuantityWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82307,26 +81579,25 @@ - (void)subscribeAttributeLampQuantityWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82334,7 +81605,8 @@ + (void)readAttributeLampQuantityWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
@@ -82343,9 +81615,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82355,14 +81626,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeLampTypeWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -82377,12 +81648,13 @@ - (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82394,13 +81666,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82409,27 +81679,25 @@ - (void)subscribeAttributeLampTypeWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82437,7 +81705,8 @@ + (void)readAttributeLampTypeWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
@@ -82446,9 +81715,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82458,14 +81726,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeLampManufacturerWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -82480,12 +81748,13 @@ - (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82497,13 +81766,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampManufacturerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82512,27 +81779,25 @@ - (void)subscribeAttributeLampManufacturerWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampManufacturerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82540,7 +81805,8 @@ + (void)readAttributeLampManufacturerWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
@@ -82549,9 +81815,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82561,14 +81826,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeLampRatedHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -82583,12 +81848,13 @@ - (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82605,13 +81871,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampRatedHoursWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82620,27 +81884,25 @@ - (void)subscribeAttributeLampRatedHoursWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampRatedHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82648,7 +81910,8 @@ + (void)readAttributeLampRatedHoursWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
@@ -82657,9 +81920,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82669,14 +81931,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeLampBurnHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -82691,12 +81953,13 @@ - (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82713,13 +81976,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampBurnHoursWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82728,27 +81989,25 @@ - (void)subscribeAttributeLampBurnHoursWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampBurnHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82756,7 +82015,8 @@ + (void)readAttributeLampBurnHoursWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
@@ -82765,9 +82025,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82777,14 +82036,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeLampAlarmModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -82799,12 +82058,13 @@ - (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82816,13 +82076,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampAlarmModeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82831,26 +82089,25 @@ - (void)subscribeAttributeLampAlarmModeWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampAlarmModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82858,7 +82115,8 @@ + (void)readAttributeLampAlarmModeWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
@@ -82867,9 +82125,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82880,14 +82137,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeLampBurnHoursTripPointWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -82902,12 +82159,13 @@ - (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)valu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -82924,13 +82182,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLampBurnHoursTripPointWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -82940,27 +82196,25 @@ - (void)subscribeAttributeLampBurnHoursTripPointWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLampBurnHoursTripPointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -82969,7 +82223,8 @@ + (void)readAttributeLampBurnHoursTripPointWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
@@ -82978,9 +82233,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -82990,14 +82244,15 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BallastConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<BallastConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -83007,28 +82262,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<BallastConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BallastConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -83037,8 +82292,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BallastConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
@@ -83047,9 +82303,8 @@ new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BallastConfigurationGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -83059,14 +82314,15 @@ new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BallastConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<BallastConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -83076,28 +82332,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<BallastConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BallastConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -83106,8 +82362,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BallastConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
@@ -83116,9 +82373,8 @@ new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BallastConfigurationAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -83128,14 +82384,15 @@ new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BallastConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<BallastConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -83144,27 +82401,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<BallastConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            BallastConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -83172,8 +82429,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(BallastConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
@@ -83182,9 +82440,8 @@ new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<BallastConfigurationAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -83194,14 +82451,14 @@ new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -83210,26 +82467,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -83237,7 +82493,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
@@ -83246,9 +82503,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -83258,14 +82514,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -83274,26 +82530,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -83301,7 +82556,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
@@ -83310,9 +82566,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84111,14 +83366,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84127,27 +83382,25 @@ - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84155,7 +83408,8 @@ + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
@@ -84164,9 +83418,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84176,14 +83429,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84192,27 +83445,25 @@ - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84220,7 +83471,8 @@ + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
@@ -84229,9 +83481,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84241,14 +83492,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84257,27 +83508,25 @@ - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84285,7 +83534,8 @@ + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
@@ -84294,9 +83544,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84306,14 +83555,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84322,26 +83571,25 @@ - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84349,7 +83597,8 @@ + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
@@ -84358,9 +83607,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84370,14 +83618,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeLightSensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLightSensorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84386,27 +83634,25 @@ - (void)subscribeAttributeLightSensorTypeWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLightSensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84414,7 +83660,8 @@ + (void)readAttributeLightSensorTypeWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
@@ -84423,9 +83670,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84435,14 +83681,15 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IlluminanceMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84452,28 +83699,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IlluminanceMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84482,8 +83729,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(IlluminanceMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
@@ -84492,9 +83740,8 @@ new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -84504,14 +83751,15 @@ new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IlluminanceMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84521,28 +83769,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IlluminanceMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84551,8 +83799,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(IlluminanceMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
@@ -84561,9 +83810,8 @@ new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -84573,14 +83821,15 @@ new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IlluminanceMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<IlluminanceMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84589,28 +83838,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<IlluminanceMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            IlluminanceMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84618,8 +83867,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(IlluminanceMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
@@ -84628,9 +83878,8 @@ new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<IlluminanceMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -84640,14 +83889,14 @@ new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84656,26 +83905,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84683,7 +83931,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
@@ -84692,9 +83941,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -84704,14 +83952,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -84720,26 +83968,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -84747,7 +83994,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
@@ -84756,9 +84004,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -85141,14 +84388,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85157,27 +84404,25 @@ - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
 
-                chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85185,7 +84430,8 @@ + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
@@ -85194,9 +84440,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -85206,14 +84451,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85222,27 +84467,25 @@ - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
 
-                chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85250,7 +84493,8 @@ + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
@@ -85259,9 +84503,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -85271,14 +84514,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85287,27 +84530,25 @@ - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
 
-                chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85315,7 +84556,8 @@ + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
@@ -85324,9 +84566,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -85336,14 +84577,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85352,26 +84593,25 @@ - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85379,7 +84619,8 @@ + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
@@ -85388,9 +84629,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -85400,14 +84640,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TemperatureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<TemperatureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85417,28 +84658,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<TemperatureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TemperatureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85447,8 +84688,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TemperatureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
@@ -85457,9 +84699,8 @@ new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TemperatureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -85469,14 +84710,15 @@ new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TemperatureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<TemperatureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85486,28 +84728,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<TemperatureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TemperatureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85516,8 +84758,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TemperatureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
@@ -85526,9 +84769,8 @@ new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TemperatureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -85538,14 +84780,15 @@ new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TemperatureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<TemperatureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85554,28 +84797,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<TemperatureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TemperatureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85583,8 +84826,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TemperatureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
@@ -85593,9 +84837,8 @@ new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TemperatureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -85605,14 +84848,14 @@ new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85621,26 +84864,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85648,7 +84890,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
@@ -85657,9 +84900,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -85669,14 +84911,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -85685,26 +84927,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -85712,7 +84953,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
@@ -85721,9 +84963,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86071,14 +85312,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86087,27 +85328,25 @@ - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86115,7 +85354,8 @@ + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
@@ -86124,9 +85364,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86136,14 +85375,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86152,27 +85391,25 @@ - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86180,7 +85417,8 @@ + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
@@ -86189,9 +85427,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86201,14 +85438,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86217,27 +85454,25 @@ - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86245,7 +85480,8 @@ + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
@@ -86254,9 +85490,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86266,14 +85501,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86282,26 +85517,25 @@ - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86309,7 +85543,8 @@ + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
@@ -86318,9 +85553,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86330,14 +85564,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86346,27 +85580,25 @@ - (void)subscribeAttributeScaledValueWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86374,7 +85606,8 @@ + (void)readAttributeScaledValueWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
@@ -86383,9 +85616,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86395,14 +85627,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86411,27 +85643,25 @@ - (void)subscribeAttributeMinScaledValueWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86439,7 +85669,8 @@ + (void)readAttributeMinScaledValueWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
@@ -86448,9 +85679,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86460,14 +85690,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86476,27 +85706,25 @@ - (void)subscribeAttributeMaxScaledValueWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86504,7 +85732,8 @@ + (void)readAttributeMaxScaledValueWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
@@ -86513,9 +85742,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86525,14 +85753,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeScaledToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeScaledToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86541,26 +85769,25 @@ - (void)subscribeAttributeScaledToleranceWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeScaledToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86568,7 +85795,8 @@ + (void)readAttributeScaledToleranceWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
@@ -86577,9 +85805,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86589,14 +85816,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeScaleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeScaleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86605,26 +85832,25 @@ - (void)subscribeAttributeScaleWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeScaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86632,7 +85858,8 @@ + (void)readAttributeScaleWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
@@ -86641,9 +85868,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86653,14 +85879,15 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PressureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<PressureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86670,28 +85897,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<PressureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PressureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86700,8 +85927,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PressureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
@@ -86710,9 +85938,8 @@ new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PressureMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -86722,14 +85949,15 @@ new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PressureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<PressureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86739,28 +85967,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<PressureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PressureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86769,8 +85997,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PressureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
@@ -86779,9 +86008,8 @@ new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PressureMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -86791,14 +86019,15 @@ new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PressureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<PressureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86807,27 +86036,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<PressureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            PressureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86835,8 +86064,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(PressureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
@@ -86845,9 +86075,8 @@ new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<PressureMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -86857,14 +86086,14 @@ new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86873,26 +86102,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86900,7 +86128,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
@@ -86909,9 +86138,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -86921,14 +86149,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -86937,26 +86165,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -86964,7 +86191,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
@@ -86973,9 +86201,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -87491,14 +86718,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87507,27 +86734,25 @@ - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
 
-                chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87535,7 +86760,8 @@ + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
@@ -87544,9 +86770,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -87556,14 +86781,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87572,27 +86797,25 @@ - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
 
-                chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87600,7 +86823,8 @@ + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
@@ -87609,9 +86833,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -87621,14 +86844,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87637,27 +86860,25 @@ - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
 
-                chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87665,7 +86886,8 @@ + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
@@ -87674,9 +86896,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -87686,14 +86907,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87702,26 +86923,25 @@ - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87729,7 +86949,8 @@ + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
@@ -87738,9 +86959,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -87750,14 +86970,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FlowMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<FlowMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87767,28 +86988,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<FlowMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FlowMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87797,8 +87018,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FlowMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
@@ -87807,9 +87029,8 @@ new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FlowMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -87819,14 +87040,15 @@ new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FlowMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<FlowMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87836,27 +87058,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<FlowMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FlowMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87865,8 +87088,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FlowMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
@@ -87875,9 +87099,8 @@ new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FlowMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -87887,14 +87110,15 @@ new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FlowMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<FlowMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87903,27 +87127,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<FlowMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            FlowMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87931,8 +87155,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(FlowMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
@@ -87941,9 +87166,8 @@ new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<FlowMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -87953,14 +87177,14 @@ new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -87969,26 +87193,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -87996,7 +87219,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
@@ -88005,9 +87229,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88017,14 +87240,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88033,26 +87256,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88060,7 +87282,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
@@ -88069,9 +87292,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88419,14 +87641,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88435,27 +87657,25 @@ - (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
 
-                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88463,7 +87683,8 @@ + (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
@@ -88472,9 +87693,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88484,14 +87704,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88500,27 +87720,25 @@ - (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
 
-                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88528,7 +87746,8 @@ + (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
@@ -88537,9 +87756,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88549,14 +87767,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88565,27 +87783,25 @@ - (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
 
-                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88593,7 +87809,8 @@ + (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
@@ -88602,9 +87819,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88614,14 +87830,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88630,26 +87846,25 @@ - (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88657,7 +87872,8 @@ + (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
@@ -88666,9 +87882,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88678,15 +87893,16 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn
-                = Callback<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
-        });
+    auto * bridge
+        = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
+                using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
+                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
+            });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88696,30 +87912,29 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::
+                    OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88728,8 +87943,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
@@ -88738,10 +87954,8 @@ new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridg
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -88751,14 +87965,15 @@ new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridg
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88768,30 +87983,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn
-                    = Callback<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::
-                        OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88800,8 +88013,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
@@ -88810,10 +88024,8 @@ new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn
-                    = Callback<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -88823,14 +88035,15 @@ new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            RelativeHumidityMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<RelativeHumidityMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88839,28 +88052,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<RelativeHumidityMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            RelativeHumidityMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88868,8 +88081,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(RelativeHumidityMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
@@ -88878,9 +88092,8 @@ new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<RelativeHumidityMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -88890,14 +88103,14 @@ new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88906,26 +88119,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88933,7 +88145,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
@@ -88942,9 +88155,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -88954,14 +88166,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -88970,26 +88182,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -88997,7 +88208,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
@@ -89006,9 +88218,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89356,14 +88567,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89372,26 +88583,25 @@ - (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89399,7 +88609,8 @@ + (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
@@ -89408,9 +88619,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89420,14 +88630,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeOccupancySensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupancySensorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89437,26 +88647,25 @@ - (void)subscribeAttributeOccupancySensorTypeWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupancySensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89465,7 +88674,8 @@ + (void)readAttributeOccupancySensorTypeWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
@@ -89474,9 +88684,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89487,14 +88696,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeOccupancySensorTypeBitmapWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOccupancySensorTypeBitmapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89504,26 +88713,25 @@ - (void)subscribeAttributeOccupancySensorTypeBitmapWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOccupancySensorTypeBitmapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89532,7 +88740,8 @@ + (void)readAttributeOccupancySensorTypeBitmapWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
@@ -89541,9 +88750,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89554,14 +88762,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributePirOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePirOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -89576,12 +88784,13 @@ - (void)writeAttributePirOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -89593,13 +88802,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePirOccupiedToUnoccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89610,26 +88817,25 @@ - (void)subscribeAttributePirOccupiedToUnoccupiedDelayWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePirOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89638,7 +88844,8 @@ + (void)readAttributePirOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
@@ -89647,9 +88854,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89660,14 +88866,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributePirUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePirUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -89682,12 +88888,13 @@ - (void)writeAttributePirUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -89699,13 +88906,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePirUnoccupiedToOccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89716,26 +88921,25 @@ - (void)subscribeAttributePirUnoccupiedToOccupiedDelayWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePirUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89744,7 +88948,8 @@ + (void)readAttributePirUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
@@ -89753,9 +88958,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89766,14 +88970,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributePirUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePirUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
@@ -89789,12 +88993,13 @@ - (void)writeAttributePirUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Non
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -89806,13 +89011,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePirUnoccupiedToOccupiedThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89823,26 +89026,25 @@ - (void)subscribeAttributePirUnoccupiedToOccupiedThresholdWithParams:(MTRSubscri
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePirUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89851,7 +89053,8 @@ + (void)readAttributePirUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttr
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
@@ -89860,9 +89063,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89873,14 +89075,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
@@ -89896,12 +89098,13 @@ - (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -89913,13 +89116,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUltrasonicOccupiedToUnoccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -89930,26 +89131,25 @@ - (void)subscribeAttributeUltrasonicOccupiedToUnoccupiedDelayWithParams:(MTRSubs
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -89958,7 +89158,8 @@ + (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithAttributeCache:(MTRA
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
@@ -89967,9 +89168,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -89980,14 +89180,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
@@ -90003,12 +89203,13 @@ - (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -90020,13 +89221,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90037,26 +89236,25 @@ - (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedDelayWithParams:(MTRSubs
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90065,7 +89263,8 @@ + (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithAttributeCache:(MTRA
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
@@ -90074,9 +89273,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -90087,14 +89285,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
@@ -90112,12 +89310,13 @@ - (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -90129,13 +89328,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90146,26 +89343,25 @@ - (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithParams:(MTR
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90174,7 +89370,8 @@ + (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithAttributeCache:(
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
@@ -90183,9 +89380,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -90196,14 +89392,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
@@ -90221,12 +89417,13 @@ - (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumbe
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -90238,13 +89435,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalContactOccupiedToUnoccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90255,26 +89450,25 @@ - (void)subscribeAttributePhysicalContactOccupiedToUnoccupiedDelayWithParams:(MT
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithAttributeCache:
@@ -90284,7 +89478,8 @@ + (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithAttributeCache:
                                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
@@ -90293,9 +89488,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -90306,14 +89500,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
@@ -90331,12 +89525,13 @@ - (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumbe
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -90348,13 +89543,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedDelayWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90365,26 +89558,25 @@ - (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedDelayWithParams:(MT
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithAttributeCache:
@@ -90394,7 +89586,8 @@ + (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithAttributeCache:
                                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
@@ -90403,9 +89596,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -90416,14 +89608,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
@@ -90441,12 +89633,13 @@ - (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSN
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -90458,13 +89651,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90475,26 +89666,25 @@ - (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithAttributeCache:
@@ -90504,7 +89694,8 @@ + (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithAttributeCa
                                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
@@ -90513,9 +89704,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -90525,14 +89715,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OccupancySensingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<OccupancySensingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90542,28 +89733,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<OccupancySensingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OccupancySensingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90572,8 +89763,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OccupancySensingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
@@ -90582,9 +89774,8 @@ new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OccupancySensingGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -90594,14 +89785,15 @@ new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OccupancySensingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<OccupancySensingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90611,28 +89803,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<OccupancySensingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OccupancySensingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90641,8 +89833,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OccupancySensingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
@@ -90651,9 +89844,8 @@ new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OccupancySensingAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -90663,14 +89855,15 @@ new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROccupancySensingAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROccupancySensingAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OccupancySensingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<OccupancySensingAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90679,27 +89872,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<OccupancySensingAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            OccupancySensingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90707,8 +89900,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROccupancySensingAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(OccupancySensingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
@@ -90717,9 +89911,8 @@ new MTROccupancySensingAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<OccupancySensingAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -90729,14 +89922,14 @@ new MTROccupancySensingAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90745,26 +89938,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90772,7 +89964,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
@@ -90781,9 +89974,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -90793,14 +89985,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -90809,26 +90001,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -90836,7 +90027,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
@@ -90845,9 +90037,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -91588,14 +90779,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeMACAddressWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMACAddressWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -91604,27 +90795,25 @@ - (void)subscribeAttributeMACAddressWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
 
-                chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMACAddressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -91632,7 +90821,8 @@ + (void)readAttributeMACAddressWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
@@ -91641,9 +90831,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -91653,14 +90842,15 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WakeOnLanGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<WakeOnLanGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -91670,27 +90860,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<WakeOnLanGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WakeOnLanGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -91699,8 +90889,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WakeOnLanGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
@@ -91709,9 +90900,8 @@ new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WakeOnLanGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -91721,14 +90911,15 @@ new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WakeOnLanAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<WakeOnLanAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -91738,27 +90929,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<WakeOnLanAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            WakeOnLanAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -91767,8 +90958,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(WakeOnLanAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
@@ -91777,9 +90969,8 @@ new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<WakeOnLanAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -91789,14 +90980,14 @@ new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWakeOnLanAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWakeOnLanAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WakeOnLanAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<WakeOnLanAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -91805,27 +90996,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<WakeOnLanAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WakeOnLanAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -91833,7 +91023,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(WakeOnLanAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
@@ -91842,9 +91033,8 @@ new MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, completion, ^(Ca
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<WakeOnLanAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -91854,14 +91044,14 @@ new MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, completion, ^(Ca
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -91870,26 +91060,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -91897,7 +91086,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
@@ -91906,9 +91096,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -91918,14 +91107,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -91934,26 +91123,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -91961,7 +91149,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
@@ -91970,9 +91159,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -92219,8 +91407,9 @@ - (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ChannelClusterChangeChannelResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Channel::Commands::ChangeChannel::Type request;
@@ -92231,11 +91420,10 @@ new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, sel
             }
             request.match = [self asCharSpan:params.match];
 
-            auto successFn = Callback<ChannelClusterChangeChannelResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params
@@ -92243,12 +91431,13 @@ - (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Channel::Commands::ChangeChannelByNumber::Type request;
@@ -92260,23 +91449,23 @@ new MTRCommandSuccessCallbackBridge(
             request.majorNumber = params.majorNumber.unsignedShortValue;
             request.minorNumber = params.minorNumber.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             Channel::Commands::SkipChannel::Type request;
@@ -92287,23 +91476,22 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.count = params.count.unsignedShortValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeChannelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelChannelListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelChannelListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelChannelListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
-            auto successFn = Callback<ChannelChannelListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeChannelListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92312,27 +91500,25 @@ - (void)subscribeAttributeChannelListWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRChannelChannelListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRChannelChannelListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
-                auto successFn = Callback<ChannelChannelListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRChannelChannelListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelChannelListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRChannelChannelListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
 
-                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRChannelChannelListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRChannelChannelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRChannelChannelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeChannelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92340,7 +91526,8 @@ + (void)readAttributeChannelListWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelChannelListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelChannelListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ChannelChannelListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
@@ -92349,9 +91536,8 @@ new MTRChannelChannelListListAttributeCallbackBridge(queue, completion, ^(Cancel
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ChannelChannelListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -92362,14 +91548,14 @@ new MTRChannelChannelListListAttributeCallbackBridge(queue, completion, ^(Cancel
 - (void)readAttributeLineupWithCompletion:(void (^)(
                                               MTRChannelClusterLineupInfo * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelLineupStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelLineupStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelLineupStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
-            auto successFn = Callback<ChannelLineupStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLineupWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92379,27 +91565,25 @@ - (void)subscribeAttributeLineupWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRChannelLineupStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRChannelLineupStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
-                auto successFn = Callback<ChannelLineupStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRChannelLineupStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelLineupStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRChannelLineupStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
 
-                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRChannelLineupStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRChannelLineupStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRChannelLineupStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLineupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92408,7 +91592,8 @@ + (void)readAttributeLineupWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                    completion:(void (^)(MTRChannelClusterLineupInfo * _Nullable value,
                                                   NSError * _Nullable error))completion
 {
-    new MTRChannelLineupStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelLineupStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ChannelLineupStructAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
@@ -92417,9 +91602,8 @@ new MTRChannelLineupStructAttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ChannelLineupStructAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -92430,14 +91614,14 @@ new MTRChannelLineupStructAttributeCallbackBridge(queue, completion, ^(Cancelabl
 - (void)readAttributeCurrentChannelWithCompletion:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                       NSError * _Nullable error))completion
 {
-    new MTRChannelCurrentChannelStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelCurrentChannelStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelCurrentChannelStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
-            auto successFn = Callback<ChannelCurrentChannelStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentChannelWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92447,27 +91631,26 @@ - (void)subscribeAttributeCurrentChannelWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
-                auto successFn = Callback<ChannelCurrentChannelStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelCurrentChannelStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
 
-                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92476,7 +91659,8 @@ + (void)readAttributeCurrentChannelWithAttributeCache:(MTRAttributeCacheContaine
                                            completion:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                           NSError * _Nullable error))completion
 {
-    new MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ChannelCurrentChannelStructAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
@@ -92485,9 +91669,8 @@ new MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ChannelCurrentChannelStructAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -92497,14 +91680,15 @@ new MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ChannelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ChannelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92514,27 +91698,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ChannelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ChannelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92543,35 +91727,36 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ChannelGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ChannelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ChannelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ChannelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92581,27 +91766,26 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ChannelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ChannelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92610,35 +91794,36 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ChannelAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ChannelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ChannelAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92647,27 +91832,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRChannelAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ChannelAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRChannelAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRChannelAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRChannelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRChannelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92675,7 +91859,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRChannelAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRChannelAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(ChannelAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
@@ -92684,9 +91869,8 @@ new MTRChannelAttributeListListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ChannelAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -92696,14 +91880,14 @@ new MTRChannelAttributeListListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92712,26 +91896,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92739,7 +91922,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
@@ -92748,9 +91932,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -92760,14 +91943,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -92776,26 +91959,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -92803,7 +91985,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
@@ -92812,9 +91995,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -93144,8 +92326,10 @@ - (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorClusterNavigateTargetResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TargetNavigator::Commands::NavigateTarget::Type request;
@@ -93160,23 +92344,22 @@ new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQ
                 definedValue_0 = [self asCharSpan:params.data];
             }
 
-            auto successFn = Callback<TargetNavigatorClusterNavigateTargetResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeTargetListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorTargetListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorTargetListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorTargetListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
-            auto successFn = Callback<TargetNavigatorTargetListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTargetListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93185,27 +92368,26 @@ - (void)subscribeAttributeTargetListWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
-                auto successFn = Callback<TargetNavigatorTargetListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorTargetListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
 
-                chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTargetListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93213,7 +92395,8 @@ + (void)readAttributeTargetListWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TargetNavigatorTargetListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
@@ -93222,9 +92405,8 @@ new MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TargetNavigatorTargetListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -93234,14 +92416,14 @@ new MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeCurrentTargetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentTargetWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93250,26 +92432,25 @@ - (void)subscribeAttributeCurrentTargetWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentTargetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93277,7 +92458,8 @@ + (void)readAttributeCurrentTargetWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
@@ -93286,9 +92468,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -93298,14 +92479,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<TargetNavigatorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93315,28 +92497,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<TargetNavigatorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93345,8 +92527,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TargetNavigatorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
@@ -93355,9 +92538,8 @@ new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TargetNavigatorGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -93367,14 +92549,15 @@ new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<TargetNavigatorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93384,27 +92567,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<TargetNavigatorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93413,8 +92597,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TargetNavigatorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
@@ -93423,9 +92608,8 @@ new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TargetNavigatorAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -93435,14 +92619,15 @@ new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<TargetNavigatorAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93451,27 +92636,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<TargetNavigatorAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TargetNavigatorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93479,8 +92664,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TargetNavigatorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
@@ -93489,9 +92675,8 @@ new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TargetNavigatorAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -93501,14 +92686,14 @@ new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93517,26 +92702,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93544,7 +92728,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
@@ -93553,9 +92738,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -93565,14 +92749,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -93581,26 +92765,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -93608,7 +92791,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
@@ -93617,9 +92801,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -93913,8 +93096,10 @@ - (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::Play::Type request;
@@ -93924,11 +93109,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)pauseWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
@@ -93942,8 +93126,10 @@ - (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::Pause::Type request;
@@ -93953,11 +93139,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopPlaybackWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
@@ -93971,8 +93156,10 @@ - (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::StopPlayback::Type request;
@@ -93982,11 +93169,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)startOverWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
@@ -94000,8 +93186,10 @@ - (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::StartOver::Type request;
@@ -94011,11 +93199,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)previousWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
@@ -94029,8 +93216,10 @@ - (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::Previous::Type request;
@@ -94040,11 +93229,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)nextWithCompletion:(void (^)(
@@ -94058,8 +93246,10 @@ - (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::Next::Type request;
@@ -94069,11 +93259,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)rewindWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
@@ -94087,8 +93276,10 @@ - (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::Rewind::Type request;
@@ -94098,11 +93289,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)fastForwardWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
@@ -94116,8 +93306,10 @@ - (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nulla
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::FastForward::Type request;
@@ -94127,11 +93319,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
@@ -94140,8 +93331,10 @@ - (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::SkipForward::Type request;
@@ -94152,11 +93345,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
             }
             request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params
@@ -94165,8 +93357,10 @@ - (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::SkipBackward::Type request;
@@ -94177,11 +93371,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
             }
             request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
@@ -94190,8 +93383,10 @@ - (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaPlayback::Commands::Seek::Type request;
@@ -94202,23 +93397,23 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, se
             }
             request.position = params.position.unsignedLongLongValue;
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
-            auto successFn = Callback<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94227,27 +93422,27 @@ - (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
-                auto successFn = Callback<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackClusterPlaybackStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94255,8 +93450,9 @@ + (void)readAttributeCurrentStateWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaPlaybackClusterPlaybackStateEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
@@ -94265,9 +93461,8 @@ new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -94277,14 +93472,14 @@ new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(
 
 - (void)readAttributeStartTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStartTimeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94293,27 +93488,25 @@ - (void)subscribeAttributeStartTimeWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStartTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94321,7 +93514,8 @@ + (void)readAttributeStartTimeWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
@@ -94330,9 +93524,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -94342,14 +93535,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDurationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94358,27 +93551,25 @@ - (void)subscribeAttributeDurationWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94386,7 +93577,8 @@ + (void)readAttributeDurationWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
@@ -94395,9 +93587,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -94408,14 +93599,15 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeSampledPositionWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                        NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackSampledPositionStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
-            auto successFn = Callback<MediaPlaybackSampledPositionStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSampledPositionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94425,27 +93617,27 @@ - (void)subscribeAttributeSampledPositionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
-                auto successFn = Callback<MediaPlaybackSampledPositionStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackSampledPositionStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSampledPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94454,8 +93646,9 @@ + (void)readAttributeSampledPositionWithAttributeCache:(MTRAttributeCacheContain
                                             completion:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                            NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaPlaybackSampledPositionStructAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
@@ -94464,9 +93657,8 @@ new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<MediaPlaybackSampledPositionStructAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -94476,14 +93668,14 @@ new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(
 
 - (void)readAttributePlaybackSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFloatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFloatAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
-            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePlaybackSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94492,26 +93684,25 @@ - (void)subscribeAttributePlaybackSpeedWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFloatAttributeCallbackSubscriptionBridge * callbackBridge = new MTRFloatAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFloatAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFloatAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
-            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRFloatAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePlaybackSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94519,7 +93710,8 @@ + (void)readAttributePlaybackSpeedWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFloatAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(FloatAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
@@ -94528,9 +93720,8 @@ new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -94540,14 +93731,14 @@ new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeSeekRangeEndWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSeekRangeEndWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94556,27 +93747,25 @@ - (void)subscribeAttributeSeekRangeEndWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSeekRangeEndWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94584,7 +93773,8 @@ + (void)readAttributeSeekRangeEndWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
@@ -94593,9 +93783,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -94605,14 +93794,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeSeekRangeStartWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSeekRangeStartWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94621,27 +93810,25 @@ - (void)subscribeAttributeSeekRangeStartWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSeekRangeStartWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94649,7 +93836,8 @@ + (void)readAttributeSeekRangeStartWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
@@ -94658,9 +93846,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -94670,14 +93857,15 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<MediaPlaybackGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94687,27 +93875,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<MediaPlaybackGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94716,8 +93904,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaPlaybackGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
@@ -94726,9 +93915,8 @@ new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<MediaPlaybackGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -94738,14 +93926,15 @@ new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<MediaPlaybackAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94755,27 +93944,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<MediaPlaybackAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94784,8 +93973,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaPlaybackAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
@@ -94794,9 +93984,8 @@ new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<MediaPlaybackAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -94806,14 +93995,14 @@ new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<MediaPlaybackAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94822,27 +94011,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<MediaPlaybackAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaPlaybackAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94850,35 +94038,36 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<MediaPlaybackAttributeListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaPlaybackAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94887,26 +94076,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94914,7 +94102,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
@@ -94923,9 +94112,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -94935,14 +94123,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -94951,26 +94139,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -94978,7 +94165,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
@@ -94987,9 +94175,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -95547,12 +94734,13 @@ - (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params co
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaInput::Commands::SelectInput::Type request;
@@ -95563,11 +94751,10 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.index = params.index.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)showInputStatusWithCompletion:(MTRStatusCompletion)completion
@@ -95579,12 +94766,13 @@ - (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaInput::Commands::ShowInputStatus::Type request;
@@ -95594,11 +94782,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)hideInputStatusWithCompletion:(MTRStatusCompletion)completion
@@ -95610,12 +94797,13 @@ - (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaInput::Commands::HideInputStatus::Type request;
@@ -95625,23 +94813,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             MediaInput::Commands::RenameInput::Type request;
@@ -95653,23 +94841,22 @@ new MTRCommandSuccessCallbackBridge(
             request.index = params.index.unsignedCharValue;
             request.name = [self asCharSpan:params.name];
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeInputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputInputListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputInputListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputInputListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
-            auto successFn = Callback<MediaInputInputListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInputListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -95678,27 +94865,26 @@ - (void)subscribeAttributeInputListWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaInputInputListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
-                auto successFn = Callback<MediaInputInputListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputInputListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaInputInputListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
 
-                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaInputInputListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaInputInputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaInputInputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -95706,7 +94892,8 @@ + (void)readAttributeInputListWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputInputListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputInputListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(MediaInputInputListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
@@ -95715,9 +94902,8 @@ new MTRMediaInputInputListListAttributeCallbackBridge(queue, completion, ^(Cance
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<MediaInputInputListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -95727,14 +94913,14 @@ new MTRMediaInputInputListListAttributeCallbackBridge(queue, completion, ^(Cance
 
 - (void)readAttributeCurrentInputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentInputWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -95743,26 +94929,25 @@ - (void)subscribeAttributeCurrentInputWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentInputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -95770,7 +94955,8 @@ + (void)readAttributeCurrentInputWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
@@ -95779,9 +94965,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -95791,14 +94976,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<MediaInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -95808,27 +94994,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<MediaInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -95837,8 +95023,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
@@ -95847,9 +95034,8 @@ new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<MediaInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -95859,14 +95045,15 @@ new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<MediaInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -95876,27 +95063,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<MediaInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            MediaInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -95905,8 +95092,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(MediaInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
@@ -95915,9 +95103,8 @@ new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<MediaInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -95927,14 +95114,14 @@ new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<MediaInputAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -95943,27 +95130,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<MediaInputAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -95971,7 +95157,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRMediaInputAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRMediaInputAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(MediaInputAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
@@ -95980,9 +95167,8 @@ new MTRMediaInputAttributeListListAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<MediaInputAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -95992,14 +95178,14 @@ new MTRMediaInputAttributeListListAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96008,26 +95194,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96035,7 +95220,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
@@ -96044,9 +95230,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -96056,14 +95241,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96072,26 +95257,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96099,7 +95283,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
@@ -96108,9 +95293,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -96422,12 +95606,13 @@ - (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params comple
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             LowPower::Commands::Sleep::Type request;
@@ -96437,23 +95622,23 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LowPowerGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<LowPowerGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96463,27 +95648,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<LowPowerGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LowPowerGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96492,8 +95677,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LowPowerGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
@@ -96502,9 +95688,8 @@ new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<LowPowerGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -96514,14 +95699,15 @@ new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LowPowerAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<LowPowerAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96531,27 +95717,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<LowPowerAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            LowPowerAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96560,35 +95746,36 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<LowPowerAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(LowPowerAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLowPowerAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLowPowerAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, LowPowerAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<LowPowerAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96597,27 +95784,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<LowPowerAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, LowPowerAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96625,7 +95811,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRLowPowerAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRLowPowerAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(LowPowerAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
@@ -96634,9 +95821,8 @@ new MTRLowPowerAttributeListListAttributeCallbackBridge(queue, completion, ^(Can
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<LowPowerAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -96646,14 +95832,14 @@ new MTRLowPowerAttributeListListAttributeCallbackBridge(queue, completion, ^(Can
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96662,26 +95848,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96689,7 +95874,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
@@ -96698,9 +95884,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -96710,14 +95895,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -96726,26 +95911,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -96753,7 +95937,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
@@ -96762,9 +95947,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -96987,8 +96171,9 @@ - (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, KeypadInputClusterSendKeyResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             KeypadInput::Commands::SendKey::Type request;
@@ -96999,23 +96184,23 @@ new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, self.
             }
             request.keyCode = static_cast<std::remove_reference_t<decltype(request.keyCode)>>(params.keyCode.unsignedCharValue);
 
-            auto successFn = Callback<KeypadInputClusterSendKeyResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            KeypadInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<KeypadInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97025,27 +96210,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<KeypadInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            KeypadInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97054,8 +96239,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(KeypadInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
@@ -97064,9 +96250,8 @@ new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<KeypadInputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -97076,14 +96261,15 @@ new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            KeypadInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<KeypadInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97093,27 +96279,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<KeypadInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            KeypadInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97122,8 +96308,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(KeypadInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
@@ -97132,9 +96319,8 @@ new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<KeypadInputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -97144,14 +96330,14 @@ new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRKeypadInputAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, KeypadInputAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<KeypadInputAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97160,27 +96346,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<KeypadInputAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, KeypadInputAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97188,7 +96373,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(KeypadInputAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
@@ -97197,9 +96383,8 @@ new MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<KeypadInputAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -97209,14 +96394,14 @@ new MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97225,26 +96410,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97252,7 +96436,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
@@ -97261,9 +96446,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -97273,14 +96457,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97289,26 +96473,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97316,7 +96499,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
@@ -97325,9 +96509,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -97548,8 +96731,10 @@ - (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherClusterLaunchResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ContentLauncher::Commands::LaunchContent::Type request;
@@ -97616,11 +96801,10 @@ new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, se
                 definedValue_0 = [self asCharSpan:params.data];
             }
 
-            auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
@@ -97629,8 +96813,10 @@ - (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherClusterLaunchResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ContentLauncher::Commands::LaunchURL::Type request;
@@ -97739,23 +96925,23 @@ new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, se
                 }
             }
 
-            auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeAcceptHeaderWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherAcceptHeaderListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
-            auto successFn = Callback<ContentLauncherAcceptHeaderListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptHeaderWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97764,27 +96950,27 @@ - (void)subscribeAttributeAcceptHeaderWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
-                auto successFn = Callback<ContentLauncherAcceptHeaderListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherAcceptHeaderListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
 
-                chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptHeaderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97792,36 +96978,37 @@ + (void)readAttributeAcceptHeaderWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<ContentLauncherAcceptHeaderListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ContentLauncherAcceptHeaderListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeSupportedStreamingProtocolsWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -97836,12 +97023,13 @@ - (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -97853,13 +97041,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeSupportedStreamingProtocolsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97869,26 +97055,25 @@ - (void)subscribeAttributeSupportedStreamingProtocolsWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeSupportedStreamingProtocolsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97897,7 +97082,8 @@ + (void)readAttributeSupportedStreamingProtocolsWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
@@ -97906,9 +97092,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -97918,14 +97103,15 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ContentLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -97935,28 +97121,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ContentLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -97965,8 +97151,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ContentLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
@@ -97975,9 +97162,8 @@ new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ContentLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -97987,14 +97173,15 @@ new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ContentLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98004,27 +97191,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ContentLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98033,8 +97221,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ContentLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
@@ -98043,9 +97232,8 @@ new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ContentLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -98055,14 +97243,15 @@ new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ContentLauncherAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98071,27 +97260,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ContentLauncherAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ContentLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98099,8 +97288,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRContentLauncherAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ContentLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
@@ -98109,9 +97299,8 @@ new MTRContentLauncherAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ContentLauncherAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -98121,14 +97310,14 @@ new MTRContentLauncherAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98137,26 +97326,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98164,7 +97352,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
@@ -98173,9 +97362,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -98185,14 +97373,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98201,26 +97389,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98228,7 +97415,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
@@ -98237,9 +97425,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -98545,12 +97732,13 @@ - (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AudioOutput::Commands::SelectOutput::Type request;
@@ -98561,23 +97749,23 @@ new MTRCommandSuccessCallbackBridge(
             }
             request.index = params.index.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AudioOutput::Commands::RenameOutput::Type request;
@@ -98589,23 +97777,22 @@ new MTRCommandSuccessCallbackBridge(
             request.index = params.index.unsignedCharValue;
             request.name = [self asCharSpan:params.name];
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeOutputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputOutputListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputOutputListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputOutputListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
-            auto successFn = Callback<AudioOutputOutputListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOutputListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98614,27 +97801,26 @@ - (void)subscribeAttributeOutputListWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
-                auto successFn = Callback<AudioOutputOutputListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputOutputListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
 
-                chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOutputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98642,7 +97828,8 @@ + (void)readAttributeOutputListWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputOutputListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputOutputListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(AudioOutputOutputListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
@@ -98651,9 +97838,8 @@ new MTRAudioOutputOutputListListAttributeCallbackBridge(queue, completion, ^(Can
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<AudioOutputOutputListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -98663,14 +97849,14 @@ new MTRAudioOutputOutputListListAttributeCallbackBridge(queue, completion, ^(Can
 
 - (void)readAttributeCurrentOutputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentOutputWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98679,26 +97865,25 @@ - (void)subscribeAttributeCurrentOutputWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentOutputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98706,7 +97891,8 @@ + (void)readAttributeCurrentOutputWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
@@ -98715,9 +97901,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -98727,14 +97912,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AudioOutputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<AudioOutputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98744,27 +97930,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<AudioOutputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AudioOutputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98773,8 +97959,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AudioOutputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
@@ -98783,9 +97970,8 @@ new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AudioOutputGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -98795,14 +97981,15 @@ new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AudioOutputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<AudioOutputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98812,27 +97999,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<AudioOutputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AudioOutputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98841,8 +98028,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AudioOutputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
@@ -98851,9 +98039,8 @@ new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AudioOutputAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -98863,14 +98050,14 @@ new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<AudioOutputAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98879,27 +98066,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<AudioOutputAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98907,7 +98093,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(AudioOutputAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
@@ -98916,9 +98103,8 @@ new MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<AudioOutputAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -98928,14 +98114,14 @@ new MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -98944,26 +98130,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -98971,7 +98156,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
@@ -98980,9 +98166,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -98992,14 +98177,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99008,26 +98193,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99035,7 +98219,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
@@ -99044,9 +98229,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -99339,8 +98523,10 @@ - (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams *)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ApplicationLauncher::Commands::LaunchApp::Type request;
@@ -99356,11 +98542,10 @@ new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQue
                 definedValue_0 = [self asByteSpan:params.data];
             }
 
-            auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
@@ -99369,8 +98554,10 @@ - (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ApplicationLauncher::Commands::StopApp::Type request;
@@ -99382,11 +98569,10 @@ new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQue
             request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
             request.application.applicationId = [self asCharSpan:params.application.applicationId];
 
-            auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
@@ -99395,8 +98581,10 @@ - (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ApplicationLauncher::Commands::HideApp::Type request;
@@ -99408,23 +98596,23 @@ new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQue
             request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
             request.application.applicationId = [self asCharSpan:params.application.applicationId];
 
-            auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeCatalogListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherCatalogListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
-            auto successFn = Callback<ApplicationLauncherCatalogListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCatalogListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99433,27 +98621,27 @@ - (void)subscribeAttributeCatalogListWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
-                auto successFn = Callback<ApplicationLauncherCatalogListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherCatalogListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
 
-                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCatalogListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99461,8 +98649,9 @@ + (void)readAttributeCatalogListWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationLauncherCatalogListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
@@ -99471,9 +98660,8 @@ new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationLauncherCatalogListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -99484,14 +98672,15 @@ new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(
 - (void)readAttributeCurrentAppWithCompletion:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                   NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherCurrentAppStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
-            auto successFn = Callback<ApplicationLauncherCurrentAppStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEP * _Nullable)value
@@ -99509,12 +98698,13 @@ - (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicat
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -99536,13 +98726,11 @@ new MTRDefaultSuccessCallbackBridge(
                     definedValue_2 = value.endpoint.unsignedShortValue;
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentAppWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99552,27 +98740,27 @@ - (void)subscribeAttributeCurrentAppWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
-                auto successFn = Callback<ApplicationLauncherCurrentAppStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherCurrentAppStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
 
-                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentAppWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99581,8 +98769,9 @@ + (void)readAttributeCurrentAppWithAttributeCache:(MTRAttributeCacheContainer *)
                                        completion:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                       NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationLauncherCurrentAppStructAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
@@ -99591,9 +98780,8 @@ new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationLauncherCurrentAppStructAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -99603,14 +98791,15 @@ new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ApplicationLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99620,28 +98809,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ApplicationLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99650,8 +98839,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
@@ -99660,9 +98850,8 @@ new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationLauncherGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -99672,14 +98861,15 @@ new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ApplicationLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99689,28 +98879,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ApplicationLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99719,8 +98909,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
@@ -99729,9 +98920,8 @@ new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationLauncherAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -99741,14 +98931,15 @@ new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ApplicationLauncherAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99757,27 +98948,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ApplicationLauncherAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99785,8 +98976,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
@@ -99795,9 +98987,8 @@ new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationLauncherAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -99807,14 +98998,14 @@ new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99823,26 +99014,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99850,7 +99040,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
@@ -99859,9 +99050,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -99871,14 +99061,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -99887,26 +99077,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -99914,7 +99103,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
@@ -99923,9 +99113,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -100233,14 +99422,14 @@ - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)en
 
 - (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100249,27 +99438,25 @@ - (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100277,7 +99464,8 @@ + (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
@@ -100286,9 +99474,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -100298,14 +99485,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100314,26 +99501,25 @@ - (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRVendorIdAttributeCallbackSubscriptionBridge * callbackBridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRVendorIdAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100341,7 +99527,8 @@ + (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
@@ -100350,9 +99537,8 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -100362,14 +99548,14 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
 
 - (void)readAttributeApplicationNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApplicationNameWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100378,27 +99564,25 @@ - (void)subscribeAttributeApplicationNameWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApplicationNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100406,7 +99590,8 @@ + (void)readAttributeApplicationNameWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
@@ -100415,9 +99600,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -100427,14 +99611,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100443,26 +99627,25 @@ - (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100470,7 +99653,8 @@ + (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
@@ -100479,9 +99663,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -100492,14 +99675,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeApplicationWithCompletion:(void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                    NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicApplicationStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicApplicationStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicApplicationStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
-            auto successFn = Callback<ApplicationBasicApplicationStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApplicationWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100509,27 +99693,27 @@ - (void)subscribeAttributeApplicationWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
-                auto successFn = Callback<ApplicationBasicApplicationStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicApplicationStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApplicationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100539,8 +99723,9 @@ + (void)readAttributeApplicationWithAttributeCache:(MTRAttributeCacheContainer *
                                             (void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                 NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicApplicationStructAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationBasicApplicationStructAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
@@ -100549,9 +99734,8 @@ new MTRApplicationBasicApplicationStructAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationBasicApplicationStructAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -100561,14 +99745,15 @@ new MTRApplicationBasicApplicationStructAttributeCallbackBridge(
 
 - (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicClusterApplicationStatusEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
-            auto successFn = Callback<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100577,28 +99762,28 @@ - (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
-                auto successFn = Callback<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicClusterApplicationStatusEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100606,8 +99791,9 @@ + (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationBasicClusterApplicationStatusEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
@@ -100616,9 +99802,8 @@ new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -100628,14 +99813,14 @@ new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(
 
 - (void)readAttributeApplicationVersionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApplicationVersionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100645,27 +99830,25 @@ - (void)subscribeAttributeApplicationVersionWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApplicationVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100674,7 +99857,8 @@ + (void)readAttributeApplicationVersionWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
@@ -100683,9 +99867,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -100695,14 +99878,15 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeAllowedVendorListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicAllowedVendorListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
-            auto successFn = Callback<ApplicationBasicAllowedVendorListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAllowedVendorListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100711,27 +99895,27 @@ - (void)subscribeAttributeAllowedVendorListWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
-                auto successFn = Callback<ApplicationBasicAllowedVendorListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicAllowedVendorListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAllowedVendorListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100739,8 +99923,9 @@ + (void)readAttributeAllowedVendorListWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationBasicAllowedVendorListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
@@ -100749,9 +99934,8 @@ new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationBasicAllowedVendorListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -100761,14 +99945,15 @@ new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ApplicationBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100778,28 +99963,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ApplicationBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100808,8 +99993,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
@@ -100818,9 +100004,8 @@ new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationBasicGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -100830,14 +100015,15 @@ new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ApplicationBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100847,28 +100033,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ApplicationBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100877,8 +100063,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
@@ -100887,9 +100074,8 @@ new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationBasicAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -100899,14 +100085,15 @@ new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ApplicationBasicAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100915,27 +100102,27 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ApplicationBasicAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ApplicationBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -100943,8 +100130,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRApplicationBasicAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ApplicationBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
@@ -100953,9 +100141,8 @@ new MTRApplicationBasicAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ApplicationBasicAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -100965,14 +100152,14 @@ new MTRApplicationBasicAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -100981,26 +100168,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101008,7 +100194,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
@@ -101017,9 +100204,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -101029,14 +100215,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -101045,26 +100231,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101072,7 +100257,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
@@ -101081,9 +100267,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -101568,8 +100753,10 @@ - (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginClusterGetSetupPINResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AccountLogin::Commands::GetSetupPIN::Type request;
@@ -101583,23 +100770,23 @@ new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue,
             }
             request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
 
-            auto successFn = Callback<AccountLoginClusterGetSetupPINResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params completion:(MTRStatusCompletion)completion
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AccountLogin::Commands::Login::Type request;
@@ -101614,11 +100801,10 @@ new MTRCommandSuccessCallbackBridge(
             request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
             request.setupPIN = [self asCharSpan:params.setupPIN];
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)logoutWithCompletion:(MTRStatusCompletion)completion
@@ -101629,12 +100815,13 @@ - (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             AccountLogin::Commands::Logout::Type request;
@@ -101647,23 +100834,23 @@ new MTRCommandSuccessCallbackBridge(
                 timedInvokeTimeoutMs.SetValue(10000);
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<AccountLoginGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -101673,27 +100860,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<AccountLoginGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101702,8 +100889,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AccountLoginGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
@@ -101712,9 +100900,8 @@ new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AccountLoginGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -101724,14 +100911,15 @@ new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<AccountLoginAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -101741,27 +100929,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<AccountLoginAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101770,8 +100958,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(AccountLoginAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
@@ -101780,9 +100969,8 @@ new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<AccountLoginAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -101792,14 +100980,14 @@ new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccountLoginAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<AccountLoginAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -101808,27 +100996,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<AccountLoginAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            AccountLoginAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101836,7 +101023,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(AccountLoginAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
@@ -101845,9 +101033,8 @@ new MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, completion, ^
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<AccountLoginAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -101857,14 +101044,14 @@ new MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, completion, ^
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -101873,26 +101060,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101900,7 +101086,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
@@ -101909,9 +101096,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -101921,14 +101107,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -101937,26 +101123,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -101964,7 +101149,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
@@ -101973,9 +101159,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102212,12 +101397,13 @@ - (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfi
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ElectricalMeasurement::Commands::GetProfileInfoCommand::Type request;
@@ -102227,11 +101413,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params
@@ -102239,12 +101424,13 @@ - (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterG
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Type request;
@@ -102257,23 +101443,22 @@ new MTRCommandSuccessCallbackBridge(
             request.startTime = params.startTime.unsignedIntValue;
             request.numberOfIntervals = params.numberOfIntervals.unsignedCharValue;
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeMeasurementTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasurementTypeWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102282,26 +101467,25 @@ - (void)subscribeAttributeMeasurementTypeWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasurementTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102309,7 +101493,8 @@ + (void)readAttributeMeasurementTypeWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
@@ -102318,9 +101503,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102330,14 +101514,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102346,26 +101530,25 @@ - (void)subscribeAttributeDcVoltageWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102373,7 +101556,8 @@ + (void)readAttributeDcVoltageWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
@@ -102382,9 +101566,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102394,14 +101577,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102410,26 +101593,25 @@ - (void)subscribeAttributeDcVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102437,7 +101619,8 @@ + (void)readAttributeDcVoltageMinWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
@@ -102446,9 +101629,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102458,14 +101640,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102474,26 +101656,25 @@ - (void)subscribeAttributeDcVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102501,7 +101682,8 @@ + (void)readAttributeDcVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
@@ -102510,9 +101692,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102522,14 +101703,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102538,26 +101719,25 @@ - (void)subscribeAttributeDcCurrentWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102565,7 +101745,8 @@ + (void)readAttributeDcCurrentWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
@@ -102574,9 +101755,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102586,14 +101766,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102602,26 +101782,25 @@ - (void)subscribeAttributeDcCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102629,7 +101808,8 @@ + (void)readAttributeDcCurrentMinWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
@@ -102638,9 +101818,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102650,14 +101829,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102666,26 +101845,25 @@ - (void)subscribeAttributeDcCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102693,7 +101871,8 @@ + (void)readAttributeDcCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
@@ -102702,9 +101881,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102714,14 +101892,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcPowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102730,26 +101908,25 @@ - (void)subscribeAttributeDcPowerWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102757,7 +101934,8 @@ + (void)readAttributeDcPowerWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
@@ -102766,9 +101944,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102778,14 +101955,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcPowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcPowerMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102794,26 +101971,25 @@ - (void)subscribeAttributeDcPowerMinWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcPowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102821,7 +101997,8 @@ + (void)readAttributeDcPowerMinWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
@@ -102830,9 +102007,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102842,14 +102018,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcPowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcPowerMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102858,26 +102034,25 @@ - (void)subscribeAttributeDcPowerMaxWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcPowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102885,7 +102060,8 @@ + (void)readAttributeDcPowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
@@ -102894,9 +102070,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102906,14 +102081,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcVoltageMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102923,26 +102098,25 @@ - (void)subscribeAttributeDcVoltageMultiplierWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -102951,7 +102125,8 @@ + (void)readAttributeDcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
@@ -102960,9 +102135,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -102972,14 +102146,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -102988,26 +102162,25 @@ - (void)subscribeAttributeDcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103015,7 +102188,8 @@ + (void)readAttributeDcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
@@ -103024,9 +102198,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103036,14 +102209,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103053,26 +102226,25 @@ - (void)subscribeAttributeDcCurrentMultiplierWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103081,7 +102253,8 @@ + (void)readAttributeDcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
@@ -103090,9 +102263,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103102,14 +102274,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103118,26 +102290,25 @@ - (void)subscribeAttributeDcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103145,7 +102316,8 @@ + (void)readAttributeDcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
@@ -103154,9 +102326,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103166,14 +102337,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcPowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103182,26 +102353,25 @@ - (void)subscribeAttributeDcPowerMultiplierWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103209,7 +102379,8 @@ + (void)readAttributeDcPowerMultiplierWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
@@ -103218,9 +102389,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103230,14 +102400,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeDcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeDcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103246,26 +102416,25 @@ - (void)subscribeAttributeDcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeDcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103273,7 +102442,8 @@ + (void)readAttributeDcPowerDivisorWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
@@ -103282,9 +102452,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103294,14 +102463,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103310,26 +102479,25 @@ - (void)subscribeAttributeAcFrequencyWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103337,7 +102505,8 @@ + (void)readAttributeAcFrequencyWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
@@ -103346,9 +102515,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103358,14 +102526,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcFrequencyMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcFrequencyMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103374,26 +102542,25 @@ - (void)subscribeAttributeAcFrequencyMinWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcFrequencyMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103401,7 +102568,8 @@ + (void)readAttributeAcFrequencyMinWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
@@ -103410,9 +102578,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103422,14 +102589,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcFrequencyMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcFrequencyMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103438,26 +102605,25 @@ - (void)subscribeAttributeAcFrequencyMaxWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcFrequencyMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103465,7 +102631,8 @@ + (void)readAttributeAcFrequencyMaxWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
@@ -103474,9 +102641,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103486,14 +102652,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeNeutralCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNeutralCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103502,26 +102668,25 @@ - (void)subscribeAttributeNeutralCurrentWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNeutralCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103529,7 +102694,8 @@ + (void)readAttributeNeutralCurrentWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
@@ -103538,9 +102704,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103550,14 +102715,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTotalActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTotalActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103566,26 +102731,25 @@ - (void)subscribeAttributeTotalActivePowerWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTotalActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103593,7 +102757,8 @@ + (void)readAttributeTotalActivePowerWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
@@ -103602,9 +102767,8 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103614,14 +102778,14 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTotalReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTotalReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103631,26 +102795,25 @@ - (void)subscribeAttributeTotalReactivePowerWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTotalReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103659,7 +102822,8 @@ + (void)readAttributeTotalReactivePowerWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
@@ -103668,9 +102832,8 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103680,14 +102843,14 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeTotalApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTotalApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103697,26 +102860,25 @@ - (void)subscribeAttributeTotalApparentPowerWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTotalApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103725,7 +102887,8 @@ + (void)readAttributeTotalApparentPowerWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
@@ -103734,9 +102897,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103747,14 +102909,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasured1stHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasured1stHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103764,26 +102926,25 @@ - (void)subscribeAttributeMeasured1stHarmonicCurrentWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasured1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103792,7 +102953,8 @@ + (void)readAttributeMeasured1stHarmonicCurrentWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
@@ -103801,9 +102963,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103814,14 +102975,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasured3rdHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasured3rdHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103831,26 +102992,25 @@ - (void)subscribeAttributeMeasured3rdHarmonicCurrentWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasured3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103859,7 +103019,8 @@ + (void)readAttributeMeasured3rdHarmonicCurrentWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
@@ -103868,9 +103029,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103881,14 +103041,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasured5thHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasured5thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103898,26 +103058,25 @@ - (void)subscribeAttributeMeasured5thHarmonicCurrentWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasured5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103926,7 +103085,8 @@ + (void)readAttributeMeasured5thHarmonicCurrentWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
@@ -103935,9 +103095,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -103948,14 +103107,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasured7thHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasured7thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -103965,26 +103124,25 @@ - (void)subscribeAttributeMeasured7thHarmonicCurrentWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasured7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -103993,7 +103151,8 @@ + (void)readAttributeMeasured7thHarmonicCurrentWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
@@ -104002,9 +103161,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104015,14 +103173,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasured9thHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasured9thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104032,26 +103190,25 @@ - (void)subscribeAttributeMeasured9thHarmonicCurrentWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasured9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104060,7 +103217,8 @@ + (void)readAttributeMeasured9thHarmonicCurrentWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
@@ -104069,9 +103227,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104082,14 +103239,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasured11thHarmonicCurrentWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasured11thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104099,26 +103256,25 @@ - (void)subscribeAttributeMeasured11thHarmonicCurrentWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasured11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104127,7 +103283,8 @@ + (void)readAttributeMeasured11thHarmonicCurrentWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
@@ -104136,9 +103293,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104149,14 +103305,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasuredPhase1stHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredPhase1stHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104167,26 +103323,25 @@ - (void)subscribeAttributeMeasuredPhase1stHarmonicCurrentWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredPhase1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104195,7 +103350,8 @@ + (void)readAttributeMeasuredPhase1stHarmonicCurrentWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
@@ -104204,9 +103360,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104217,14 +103372,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredPhase3rdHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104235,26 +103390,25 @@ - (void)subscribeAttributeMeasuredPhase3rdHarmonicCurrentWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104263,7 +103417,8 @@ + (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
@@ -104272,9 +103427,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104285,14 +103439,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasuredPhase5thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredPhase5thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104303,26 +103457,25 @@ - (void)subscribeAttributeMeasuredPhase5thHarmonicCurrentWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredPhase5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104331,7 +103484,8 @@ + (void)readAttributeMeasuredPhase5thHarmonicCurrentWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
@@ -104340,9 +103494,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104353,14 +103506,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasuredPhase7thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredPhase7thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104371,26 +103524,25 @@ - (void)subscribeAttributeMeasuredPhase7thHarmonicCurrentWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredPhase7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104399,7 +103551,8 @@ + (void)readAttributeMeasuredPhase7thHarmonicCurrentWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
@@ -104408,9 +103561,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104421,14 +103573,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasuredPhase9thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredPhase9thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104439,26 +103591,25 @@ - (void)subscribeAttributeMeasuredPhase9thHarmonicCurrentWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredPhase9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104467,7 +103618,8 @@ + (void)readAttributeMeasuredPhase9thHarmonicCurrentWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
@@ -104476,9 +103628,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104489,14 +103640,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeMeasuredPhase11thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeMeasuredPhase11thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104507,26 +103658,25 @@ - (void)subscribeAttributeMeasuredPhase11thHarmonicCurrentWithParams:(MTRSubscri
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeMeasuredPhase11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104535,7 +103685,8 @@ + (void)readAttributeMeasuredPhase11thHarmonicCurrentWithAttributeCache:(MTRAttr
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
@@ -104544,9 +103695,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104556,14 +103706,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcFrequencyMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcFrequencyMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104573,26 +103723,25 @@ - (void)subscribeAttributeAcFrequencyMultiplierWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcFrequencyMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104601,7 +103750,8 @@ + (void)readAttributeAcFrequencyMultiplierWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
@@ -104610,9 +103760,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104622,14 +103771,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcFrequencyDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcFrequencyDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104639,26 +103788,25 @@ - (void)subscribeAttributeAcFrequencyDivisorWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcFrequencyDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104667,7 +103815,8 @@ + (void)readAttributeAcFrequencyDivisorWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
@@ -104676,9 +103825,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104688,14 +103836,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104704,26 +103852,25 @@ - (void)subscribeAttributePowerMultiplierWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104731,7 +103878,8 @@ + (void)readAttributePowerMultiplierWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
@@ -104740,9 +103888,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104752,14 +103899,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104768,26 +103915,25 @@ - (void)subscribeAttributePowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104795,7 +103941,8 @@ + (void)readAttributePowerDivisorWithAttributeCache:(MTRAttributeCacheContainer
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
@@ -104804,9 +103951,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104817,14 +103963,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeHarmonicCurrentMultiplierWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeHarmonicCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104834,26 +103980,25 @@ - (void)subscribeAttributeHarmonicCurrentMultiplierWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104862,7 +104007,8 @@ + (void)readAttributeHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
@@ -104871,9 +104017,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104884,14 +104029,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributePhaseHarmonicCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePhaseHarmonicCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104902,26 +104047,25 @@ - (void)subscribeAttributePhaseHarmonicCurrentMultiplierWithParams:(MTRSubscribe
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePhaseHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104930,7 +104074,8 @@ + (void)readAttributePhaseHarmonicCurrentMultiplierWithAttributeCache:(MTRAttrib
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
@@ -104939,9 +104084,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -104951,14 +104095,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeInstantaneousVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstantaneousVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -104968,26 +104112,25 @@ - (void)subscribeAttributeInstantaneousVoltageWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstantaneousVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -104996,7 +104139,8 @@ + (void)readAttributeInstantaneousVoltageWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
@@ -105005,9 +104149,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105018,14 +104161,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeInstantaneousLineCurrentWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstantaneousLineCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105035,26 +104178,25 @@ - (void)subscribeAttributeInstantaneousLineCurrentWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstantaneousLineCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105063,7 +104205,8 @@ + (void)readAttributeInstantaneousLineCurrentWithAttributeCache:(MTRAttributeCac
                                                      completion:
                                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
@@ -105072,9 +104215,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105085,14 +104227,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeInstantaneousActiveCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstantaneousActiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105102,26 +104244,25 @@ - (void)subscribeAttributeInstantaneousActiveCurrentWithParams:(MTRSubscribePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstantaneousActiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105130,7 +104271,8 @@ + (void)readAttributeInstantaneousActiveCurrentWithAttributeCache:(MTRAttributeC
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
@@ -105139,9 +104281,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105152,14 +104293,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeInstantaneousReactiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstantaneousReactiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105170,26 +104311,25 @@ - (void)subscribeAttributeInstantaneousReactiveCurrentWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstantaneousReactiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105198,7 +104338,8 @@ + (void)readAttributeInstantaneousReactiveCurrentWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
@@ -105207,9 +104348,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105219,14 +104359,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInstantaneousPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInstantaneousPowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105236,26 +104376,25 @@ - (void)subscribeAttributeInstantaneousPowerWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInstantaneousPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105264,7 +104403,8 @@ + (void)readAttributeInstantaneousPowerWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
@@ -105273,9 +104413,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105285,14 +104424,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105301,26 +104440,25 @@ - (void)subscribeAttributeRmsVoltageWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105328,7 +104466,8 @@ + (void)readAttributeRmsVoltageWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
@@ -105337,9 +104476,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105349,14 +104487,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105365,26 +104503,25 @@ - (void)subscribeAttributeRmsVoltageMinWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105392,7 +104529,8 @@ + (void)readAttributeRmsVoltageMinWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
@@ -105401,9 +104539,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105413,14 +104550,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105429,26 +104566,25 @@ - (void)subscribeAttributeRmsVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105456,7 +104592,8 @@ + (void)readAttributeRmsVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
@@ -105465,9 +104602,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105477,14 +104613,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105493,26 +104629,25 @@ - (void)subscribeAttributeRmsCurrentWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105520,7 +104655,8 @@ + (void)readAttributeRmsCurrentWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
@@ -105529,9 +104665,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105541,14 +104676,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105557,26 +104692,25 @@ - (void)subscribeAttributeRmsCurrentMinWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105584,7 +104718,8 @@ + (void)readAttributeRmsCurrentMinWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
@@ -105593,9 +104728,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105605,14 +104739,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105621,26 +104755,25 @@ - (void)subscribeAttributeRmsCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105648,7 +104781,8 @@ + (void)readAttributeRmsCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
@@ -105657,9 +104791,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105669,14 +104802,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105685,26 +104818,25 @@ - (void)subscribeAttributeActivePowerWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105712,7 +104844,8 @@ + (void)readAttributeActivePowerWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
@@ -105721,9 +104854,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105733,14 +104865,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerMinWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105749,26 +104881,25 @@ - (void)subscribeAttributeActivePowerMinWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105776,7 +104907,8 @@ + (void)readAttributeActivePowerMinWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
@@ -105785,9 +104917,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105797,14 +104928,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerMaxWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105813,26 +104944,25 @@ - (void)subscribeAttributeActivePowerMaxWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105840,7 +104970,8 @@ + (void)readAttributeActivePowerMaxWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
@@ -105849,9 +104980,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105861,14 +104991,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105877,26 +105007,25 @@ - (void)subscribeAttributeReactivePowerWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105904,7 +105033,8 @@ + (void)readAttributeReactivePowerWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
@@ -105913,9 +105043,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105925,14 +105054,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -105941,26 +105070,25 @@ - (void)subscribeAttributeApparentPowerWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -105968,7 +105096,8 @@ + (void)readAttributeApparentPowerWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
@@ -105977,9 +105106,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -105989,14 +105117,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePowerFactorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePowerFactorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106005,26 +105133,25 @@ - (void)subscribeAttributePowerFactorWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePowerFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106032,7 +105159,8 @@ + (void)readAttributePowerFactorWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
@@ -106041,9 +105169,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106054,14 +105181,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeAverageRmsVoltageMeasurementPeriodWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _Nonnull)value
@@ -106077,12 +105204,13 @@ - (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _N
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -106094,13 +105222,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106111,26 +105237,25 @@ - (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodWithParams:(MTRSubsc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsVoltageMeasurementPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106139,7 +105264,8 @@ + (void)readAttributeAverageRmsVoltageMeasurementPeriodWithAttributeCache:(MTRAt
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
@@ -106148,9 +105274,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106161,14 +105286,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAverageRmsUnderVoltageCounterWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -106183,12 +105308,13 @@ - (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnul
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -106200,13 +105326,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsUnderVoltageCounterWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106217,26 +105341,25 @@ - (void)subscribeAttributeAverageRmsUnderVoltageCounterWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsUnderVoltageCounterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106245,7 +105368,8 @@ + (void)readAttributeAverageRmsUnderVoltageCounterWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
@@ -106254,9 +105378,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106267,14 +105390,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeOverVoltagePeriodWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -106289,12 +105412,13 @@ - (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -106306,13 +105430,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeOverVoltagePeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106322,26 +105444,25 @@ - (void)subscribeAttributeRmsExtremeOverVoltagePeriodWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeOverVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106350,7 +105471,8 @@ + (void)readAttributeRmsExtremeOverVoltagePeriodWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
@@ -106359,9 +105481,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106372,14 +105493,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeUnderVoltagePeriodWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -106394,12 +105515,13 @@ - (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -106411,13 +105533,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeUnderVoltagePeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106428,26 +105548,25 @@ - (void)subscribeAttributeRmsExtremeUnderVoltagePeriodWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeUnderVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106456,7 +105575,8 @@ + (void)readAttributeRmsExtremeUnderVoltagePeriodWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
@@ -106465,9 +105585,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106477,14 +105596,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageSagPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -106499,12 +105618,13 @@ - (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -106516,13 +105636,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSagPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106532,26 +105650,25 @@ - (void)subscribeAttributeRmsVoltageSagPeriodWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSagPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106560,7 +105677,8 @@ + (void)readAttributeRmsVoltageSagPeriodWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
@@ -106569,9 +105687,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106581,14 +105698,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageSwellPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -106603,12 +105720,13 @@ - (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -106620,13 +105738,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSwellPeriodWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106636,26 +105752,25 @@ - (void)subscribeAttributeRmsVoltageSwellPeriodWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSwellPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106664,7 +105779,8 @@ + (void)readAttributeRmsVoltageSwellPeriodWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
@@ -106673,9 +105789,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106685,14 +105800,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcVoltageMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106702,26 +105817,25 @@ - (void)subscribeAttributeAcVoltageMultiplierWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106730,7 +105844,8 @@ + (void)readAttributeAcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
@@ -106739,9 +105854,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106751,14 +105865,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106767,26 +105881,25 @@ - (void)subscribeAttributeAcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106794,7 +105907,8 @@ + (void)readAttributeAcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
@@ -106803,9 +105917,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106815,14 +105928,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106832,26 +105945,25 @@ - (void)subscribeAttributeAcCurrentMultiplierWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106860,7 +105972,8 @@ + (void)readAttributeAcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
@@ -106869,9 +105982,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106881,14 +105993,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106897,26 +106009,25 @@ - (void)subscribeAttributeAcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106924,7 +106035,8 @@ + (void)readAttributeAcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
@@ -106933,9 +106045,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -106945,14 +106056,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcPowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -106961,26 +106072,25 @@ - (void)subscribeAttributeAcPowerMultiplierWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -106988,7 +106098,8 @@ + (void)readAttributeAcPowerMultiplierWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
@@ -106997,9 +106108,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107009,14 +106119,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107025,26 +106135,25 @@ - (void)subscribeAttributeAcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107052,7 +106161,8 @@ + (void)readAttributeAcPowerDivisorWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
@@ -107061,9 +106171,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107073,14 +106182,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -107095,12 +106204,13 @@ - (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -107112,13 +106222,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOverloadAlarmsMaskWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107128,26 +106236,25 @@ - (void)subscribeAttributeOverloadAlarmsMaskWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107156,7 +106263,8 @@ + (void)readAttributeOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
@@ -107165,9 +106273,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107177,14 +106284,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107193,26 +106300,25 @@ - (void)subscribeAttributeVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107220,7 +106326,8 @@ + (void)readAttributeVoltageOverloadWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
@@ -107229,9 +106336,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107241,14 +106347,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107257,26 +106363,25 @@ - (void)subscribeAttributeCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107284,7 +106389,8 @@ + (void)readAttributeCurrentOverloadWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
@@ -107293,9 +106399,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107305,14 +106410,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -107327,12 +106432,13 @@ - (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -107344,13 +106450,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcOverloadAlarmsMaskWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107360,26 +106464,25 @@ - (void)subscribeAttributeAcOverloadAlarmsMaskWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107388,7 +106491,8 @@ + (void)readAttributeAcOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
@@ -107397,9 +106501,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107409,14 +106512,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107425,26 +106528,25 @@ - (void)subscribeAttributeAcVoltageOverloadWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107452,7 +106554,8 @@ + (void)readAttributeAcVoltageOverloadWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
@@ -107461,9 +106564,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107473,14 +106575,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107489,26 +106591,25 @@ - (void)subscribeAttributeAcCurrentOverloadWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107516,7 +106617,8 @@ + (void)readAttributeAcCurrentOverloadWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
@@ -107525,9 +106627,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107537,14 +106638,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAcActivePowerOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcActivePowerOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107554,26 +106655,25 @@ - (void)subscribeAttributeAcActivePowerOverloadWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcActivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107582,7 +106682,8 @@ + (void)readAttributeAcActivePowerOverloadWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
@@ -107591,9 +106692,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107604,14 +106704,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAcReactivePowerOverloadWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcReactivePowerOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107621,26 +106721,25 @@ - (void)subscribeAttributeAcReactivePowerOverloadWithParams:(MTRSubscribeParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcReactivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107649,7 +106748,8 @@ + (void)readAttributeAcReactivePowerOverloadWithAttributeCache:(MTRAttributeCach
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
@@ -107658,9 +106758,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107670,14 +106769,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeAverageRmsOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsOverVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107687,26 +106786,25 @@ - (void)subscribeAttributeAverageRmsOverVoltageWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107715,7 +106813,8 @@ + (void)readAttributeAverageRmsOverVoltageWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
@@ -107724,9 +106823,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107737,14 +106835,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAverageRmsUnderVoltageWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsUnderVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107754,26 +106852,25 @@ - (void)subscribeAttributeAverageRmsUnderVoltageWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107782,7 +106879,8 @@ + (void)readAttributeAverageRmsUnderVoltageWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
@@ -107791,9 +106889,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107803,14 +106900,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsExtremeOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeOverVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107820,26 +106917,25 @@ - (void)subscribeAttributeRmsExtremeOverVoltageWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107848,7 +106944,8 @@ + (void)readAttributeRmsExtremeOverVoltageWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
@@ -107857,9 +106954,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107870,14 +106966,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeUnderVoltageWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeUnderVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107887,26 +106983,25 @@ - (void)subscribeAttributeRmsExtremeUnderVoltageWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107915,7 +107010,8 @@ + (void)readAttributeRmsExtremeUnderVoltageWithAttributeCache:(MTRAttributeCache
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
@@ -107924,9 +107020,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -107936,14 +107031,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageSagWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSagWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -107952,26 +107047,25 @@ - (void)subscribeAttributeRmsVoltageSagWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSagWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -107979,7 +107073,8 @@ + (void)readAttributeRmsVoltageSagWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
@@ -107988,9 +107083,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108000,14 +107094,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageSwellWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSwellWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108016,26 +107110,25 @@ - (void)subscribeAttributeRmsVoltageSwellWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSwellWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108043,7 +107136,8 @@ + (void)readAttributeRmsVoltageSwellWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
@@ -108052,9 +107146,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108064,14 +107157,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeLineCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLineCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108080,26 +107173,25 @@ - (void)subscribeAttributeLineCurrentPhaseBWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLineCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108107,7 +107199,8 @@ + (void)readAttributeLineCurrentPhaseBWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
@@ -108116,9 +107209,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108128,14 +107220,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108145,26 +107237,25 @@ - (void)subscribeAttributeActiveCurrentPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108173,7 +107264,8 @@ + (void)readAttributeActiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
@@ -108182,9 +107274,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108194,14 +107285,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReactiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReactiveCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108211,26 +107302,25 @@ - (void)subscribeAttributeReactiveCurrentPhaseBWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReactiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108239,7 +107329,8 @@ + (void)readAttributeReactiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
@@ -108248,9 +107339,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108260,14 +107350,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltagePhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltagePhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108276,26 +107366,25 @@ - (void)subscribeAttributeRmsVoltagePhaseBWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltagePhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108303,7 +107392,8 @@ + (void)readAttributeRmsVoltagePhaseBWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
@@ -108312,9 +107402,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108324,14 +107413,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108341,26 +107430,25 @@ - (void)subscribeAttributeRmsVoltageMinPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108369,7 +107457,8 @@ + (void)readAttributeRmsVoltageMinPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
@@ -108378,9 +107467,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108390,14 +107478,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108407,26 +107495,25 @@ - (void)subscribeAttributeRmsVoltageMaxPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108435,7 +107522,8 @@ + (void)readAttributeRmsVoltageMaxPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
@@ -108444,9 +107532,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108456,14 +107543,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108472,26 +107559,25 @@ - (void)subscribeAttributeRmsCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108499,7 +107585,8 @@ + (void)readAttributeRmsCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
@@ -108508,9 +107595,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108520,14 +107606,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108537,26 +107623,25 @@ - (void)subscribeAttributeRmsCurrentMinPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108565,7 +107650,8 @@ + (void)readAttributeRmsCurrentMinPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
@@ -108574,9 +107660,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108586,14 +107671,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108603,26 +107688,25 @@ - (void)subscribeAttributeRmsCurrentMaxPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108631,7 +107715,8 @@ + (void)readAttributeRmsCurrentMaxPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
@@ -108640,9 +107725,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108652,14 +107736,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108668,26 +107752,25 @@ - (void)subscribeAttributeActivePowerPhaseBWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108695,7 +107778,8 @@ + (void)readAttributeActivePowerPhaseBWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
@@ -108704,9 +107788,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108716,14 +107799,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108733,26 +107816,25 @@ - (void)subscribeAttributeActivePowerMinPhaseBWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108761,7 +107843,8 @@ + (void)readAttributeActivePowerMinPhaseBWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
@@ -108770,9 +107853,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108782,14 +107864,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108799,26 +107881,25 @@ - (void)subscribeAttributeActivePowerMaxPhaseBWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108827,7 +107908,8 @@ + (void)readAttributeActivePowerMaxPhaseBWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
@@ -108836,9 +107918,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108848,14 +107929,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReactivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReactivePowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108865,26 +107946,25 @@ - (void)subscribeAttributeReactivePowerPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReactivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108893,7 +107973,8 @@ + (void)readAttributeReactivePowerPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
@@ -108902,9 +107983,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108914,14 +107994,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeApparentPowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApparentPowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108931,26 +108011,25 @@ - (void)subscribeAttributeApparentPowerPhaseBWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApparentPowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -108959,7 +108038,8 @@ + (void)readAttributeApparentPowerPhaseBWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
@@ -108968,9 +108048,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -108980,14 +108059,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePowerFactorPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePowerFactorPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -108996,26 +108075,25 @@ - (void)subscribeAttributePowerFactorPhaseBWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePowerFactorPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109023,7 +108101,8 @@ + (void)readAttributePowerFactorPhaseBWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
@@ -109032,9 +108111,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109045,14 +108123,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109063,26 +108141,25 @@ - (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithParams:(MT
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithAttributeCache:
@@ -109092,7 +108169,8 @@ + (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithAttributeCache:
                                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
@@ -109101,9 +108179,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109114,14 +108191,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109132,26 +108209,25 @@ - (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseBWithParams:(MTRSubsc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109160,7 +108236,8 @@ + (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithAttributeCache:(MTRAt
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
@@ -109169,9 +108246,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109182,14 +108258,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109200,26 +108276,25 @@ - (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseBWithParams:(MTRSubs
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109228,7 +108303,8 @@ + (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithAttributeCache:(MTRA
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
@@ -109237,9 +108313,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109250,14 +108325,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109268,26 +108343,25 @@ - (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseBWithParams:(MTRSubscr
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109296,7 +108370,8 @@ + (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithAttributeCache:(MTRAtt
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
@@ -109305,9 +108380,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109318,14 +108392,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109336,26 +108410,25 @@ - (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithParams:(MTRSubsc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109364,7 +108437,8 @@ + (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithAttributeCache:(MTRAt
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
@@ -109373,9 +108447,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109386,14 +108459,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsVoltageSagPeriodPhaseBWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSagPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109403,26 +108476,25 @@ - (void)subscribeAttributeRmsVoltageSagPeriodPhaseBWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSagPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109431,7 +108503,8 @@ + (void)readAttributeRmsVoltageSagPeriodPhaseBWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
@@ -109440,9 +108513,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109453,14 +108525,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsVoltageSwellPeriodPhaseBWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSwellPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109470,26 +108542,25 @@ - (void)subscribeAttributeRmsVoltageSwellPeriodPhaseBWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSwellPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109498,7 +108569,8 @@ + (void)readAttributeRmsVoltageSwellPeriodPhaseBWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
@@ -109507,9 +108579,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109519,14 +108590,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeLineCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLineCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109535,26 +108606,25 @@ - (void)subscribeAttributeLineCurrentPhaseCWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLineCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109562,7 +108632,8 @@ + (void)readAttributeLineCurrentPhaseCWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
@@ -109571,9 +108642,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109583,14 +108653,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActiveCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109600,26 +108670,25 @@ - (void)subscribeAttributeActiveCurrentPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109628,7 +108697,8 @@ + (void)readAttributeActiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
@@ -109637,9 +108707,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109649,14 +108718,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReactiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReactiveCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109666,26 +108735,25 @@ - (void)subscribeAttributeReactiveCurrentPhaseCWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReactiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109694,7 +108762,8 @@ + (void)readAttributeReactiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
@@ -109703,9 +108772,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109715,14 +108783,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltagePhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltagePhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109731,26 +108799,25 @@ - (void)subscribeAttributeRmsVoltagePhaseCWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltagePhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109758,7 +108825,8 @@ + (void)readAttributeRmsVoltagePhaseCWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
@@ -109767,9 +108835,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109779,14 +108846,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109796,26 +108863,25 @@ - (void)subscribeAttributeRmsVoltageMinPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109824,7 +108890,8 @@ + (void)readAttributeRmsVoltageMinPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
@@ -109833,9 +108900,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109845,14 +108911,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsVoltageMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109862,26 +108928,25 @@ - (void)subscribeAttributeRmsVoltageMaxPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109890,7 +108955,8 @@ + (void)readAttributeRmsVoltageMaxPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
@@ -109899,9 +108965,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109911,14 +108976,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109927,26 +108992,25 @@ - (void)subscribeAttributeRmsCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -109954,7 +109018,8 @@ + (void)readAttributeRmsCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
@@ -109963,9 +109028,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -109975,14 +109039,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -109992,26 +109056,25 @@ - (void)subscribeAttributeRmsCurrentMinPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110020,7 +109083,8 @@ + (void)readAttributeRmsCurrentMinPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
@@ -110029,9 +109093,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110041,14 +109104,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRmsCurrentMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsCurrentMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110058,26 +109121,25 @@ - (void)subscribeAttributeRmsCurrentMaxPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsCurrentMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110086,7 +109148,8 @@ + (void)readAttributeRmsCurrentMaxPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
@@ -110095,9 +109158,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110107,14 +109169,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110123,26 +109185,25 @@ - (void)subscribeAttributeActivePowerPhaseCWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110150,7 +109211,8 @@ + (void)readAttributeActivePowerPhaseCWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
@@ -110159,9 +109221,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110171,14 +109232,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110188,26 +109249,25 @@ - (void)subscribeAttributeActivePowerMinPhaseCWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110216,7 +109276,8 @@ + (void)readAttributeActivePowerMinPhaseCWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
@@ -110225,9 +109286,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110237,14 +109297,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeActivePowerMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeActivePowerMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110254,26 +109314,25 @@ - (void)subscribeAttributeActivePowerMaxPhaseCWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeActivePowerMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110282,7 +109341,8 @@ + (void)readAttributeActivePowerMaxPhaseCWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
@@ -110291,9 +109351,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110303,14 +109362,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeReactivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeReactivePowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110320,26 +109379,25 @@ - (void)subscribeAttributeReactivePowerPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeReactivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110348,7 +109406,8 @@ + (void)readAttributeReactivePowerPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
@@ -110357,9 +109416,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110369,14 +109427,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeApparentPowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeApparentPowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110386,26 +109444,25 @@ - (void)subscribeAttributeApparentPowerPhaseCWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeApparentPowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110414,7 +109471,8 @@ + (void)readAttributeApparentPowerPhaseCWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
@@ -110423,9 +109481,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110435,14 +109492,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributePowerFactorPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributePowerFactorPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110451,26 +109508,25 @@ - (void)subscribeAttributePowerFactorPhaseCWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributePowerFactorPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110478,7 +109534,8 @@ + (void)readAttributePowerFactorPhaseCWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
@@ -110487,9 +109544,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110500,14 +109556,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 - (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110518,26 +109574,25 @@ - (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithParams:(MT
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithAttributeCache:
@@ -110547,7 +109602,8 @@ + (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithAttributeCache:
                                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
@@ -110556,9 +109612,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110569,14 +109624,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110587,26 +109642,25 @@ - (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseCWithParams:(MTRSubsc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110615,7 +109669,8 @@ + (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithAttributeCache:(MTRAt
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
@@ -110624,9 +109679,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110637,14 +109691,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110655,26 +109709,25 @@ - (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseCWithParams:(MTRSubs
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110683,7 +109736,8 @@ + (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithAttributeCache:(MTRA
                                                                 completion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
@@ -110692,9 +109746,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110705,14 +109758,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110723,26 +109776,25 @@ - (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseCWithParams:(MTRSubscr
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110751,7 +109803,8 @@ + (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithAttributeCache:(MTRAtt
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
@@ -110760,9 +109813,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110773,14 +109825,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110791,26 +109843,25 @@ - (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithParams:(MTRSubsc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110819,7 +109870,8 @@ + (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithAttributeCache:(MTRAt
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
@@ -110828,9 +109880,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110841,14 +109892,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsVoltageSagPeriodPhaseCWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSagPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110858,26 +109909,25 @@ - (void)subscribeAttributeRmsVoltageSagPeriodPhaseCWithParams:(MTRSubscribeParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSagPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110886,7 +109936,8 @@ + (void)readAttributeRmsVoltageSagPeriodPhaseCWithAttributeCache:(MTRAttributeCa
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
@@ -110895,9 +109946,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110908,14 +109958,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 - (void)readAttributeRmsVoltageSwellPeriodPhaseCWithCompletion:(void (^)(
                                                                    NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRmsVoltageSwellPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110925,26 +109975,25 @@ - (void)subscribeAttributeRmsVoltageSwellPeriodPhaseCWithParams:(MTRSubscribePar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRmsVoltageSwellPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -110953,7 +110002,8 @@ + (void)readAttributeRmsVoltageSwellPeriodPhaseCWithAttributeCache:(MTRAttribute
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
@@ -110962,9 +110012,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -110974,14 +110023,15 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ElectricalMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<ElectricalMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -110991,28 +110041,28 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<ElectricalMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ElectricalMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -111021,8 +110071,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ElectricalMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
@@ -111031,9 +110082,8 @@ new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ElectricalMeasurementGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -111043,14 +110093,15 @@ new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ElectricalMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<ElectricalMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -111060,28 +110111,28 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<ElectricalMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ElectricalMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -111090,8 +110141,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ElectricalMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
@@ -111100,9 +110152,8 @@ new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ElectricalMeasurementAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -111112,14 +110163,15 @@ new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ElectricalMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<ElectricalMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -111128,27 +110180,28 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<ElectricalMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            ElectricalMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -111156,8 +110209,9 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(ElectricalMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
@@ -111166,9 +110220,8 @@ new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<ElectricalMeasurementAttributeListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -111178,14 +110231,14 @@ new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -111194,26 +110247,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -111221,7 +110273,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
@@ -111230,9 +110283,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -111242,14 +110294,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -111258,26 +110310,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -111285,7 +110336,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
@@ -111294,9 +110346,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -116159,12 +115210,13 @@ - (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params compl
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::Test::Type request;
@@ -116174,11 +115226,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testNotHandledWithCompletion:(MTRStatusCompletion)completion
@@ -116190,12 +115241,13 @@ - (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestNotHandled::Type request;
@@ -116205,11 +115257,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testSpecificWithCompletion:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
@@ -116223,8 +115274,10 @@ - (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nulla
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestSpecificResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestSpecific::Type request;
@@ -116234,11 +115287,10 @@ new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue,
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterTestSpecificResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testUnknownCommandWithCompletion:(MTRStatusCompletion)completion
@@ -116250,12 +115302,13 @@ - (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandPar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestUnknownCommand::Type request;
@@ -116265,11 +115318,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams *)params
@@ -116278,8 +115330,10 @@ - (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestAddArgumentsResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestAddArguments::Type request;
@@ -116291,11 +115345,10 @@ new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQue
             request.arg1 = params.arg1.unsignedCharValue;
             request.arg2 = params.arg2.unsignedCharValue;
 
-            auto successFn = Callback<TestClusterClusterTestAddArgumentsResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgumentRequestParams *)params
@@ -116304,8 +115357,10 @@ - (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestSimpleArgumentResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestSimpleArgumentRequest::Type request;
@@ -116316,11 +115371,10 @@ new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQ
             }
             request.arg1 = params.arg1.boolValue;
 
-            auto successFn = Callback<TestClusterClusterTestSimpleArgumentResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStructArrayArgumentRequestParams *)params
@@ -116330,8 +115384,10 @@ - (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStruc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestStructArrayArgumentResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestStructArrayArgumentRequest::Type request;
@@ -116551,11 +115607,10 @@ new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.call
             request.arg5 = static_cast<std::remove_reference_t<decltype(request.arg5)>>(params.arg5.unsignedCharValue);
             request.arg6 = params.arg6.boolValue;
 
-            auto successFn = Callback<TestClusterClusterTestStructArrayArgumentResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgumentRequestParams *)params
@@ -116564,8 +115619,9 @@ - (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestStructArgumentRequest::Type request;
@@ -116583,11 +115639,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.
             request.arg1.g = params.arg1.g.floatValue;
             request.arg1.h = params.arg1.h.doubleValue;
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructArgumentRequestParams *)params
@@ -116596,8 +115651,9 @@ - (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNest
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestNestedStructArgumentRequest::Type request;
@@ -116617,11 +115673,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.
             request.arg1.c.g = params.arg1.c.g.floatValue;
             request.arg1.c.h = params.arg1.c.h.doubleValue;
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListStructArgumentRequestParams *)params
@@ -116630,8 +115685,9 @@ - (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListSt
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestListStructArgumentRequest::Type request;
@@ -116672,11 +115728,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt8UArgumentRequestParams *)params
@@ -116685,8 +115740,9 @@ - (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestListInt8UArgumentRequest::Type request;
@@ -116718,11 +115774,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructListArgumentRequestParams *)params
@@ -116731,8 +115786,9 @@ - (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTest
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestNestedStructListArgumentRequest::Type request;
@@ -116849,11 +115905,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testListNestedStructListArgumentRequestWithParams:
@@ -116863,8 +115918,9 @@ - (void)testListNestedStructListArgumentRequestWithParams:
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestListNestedStructListArgumentRequest::Type request;
@@ -117006,11 +116062,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, self.
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8UReverseRequestParams *)params
@@ -117019,8 +116074,10 @@ - (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestListInt8UReverseResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestListInt8UReverseRequest::Type request;
@@ -117052,11 +116109,10 @@ new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbac
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterTestListInt8UReverseResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams *)params
@@ -117065,8 +116121,9 @@ - (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestEnumsResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestEnumsRequest::Type request;
@@ -117078,11 +116135,10 @@ new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, sel
             request.arg1 = static_cast<std::remove_reference_t<decltype(request.arg1)>>(params.arg1.unsignedShortValue);
             request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
 
-            auto successFn = Callback<TestClusterClusterTestEnumsResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullableOptionalRequestParams * _Nullable)params
@@ -117091,8 +116147,10 @@ - (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullable
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestNullableOptionalResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestNullableOptionalRequest::Type request;
@@ -117113,11 +116171,10 @@ new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbac
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterTestNullableOptionalResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestComplexNullableOptionalRequestParams *)params
@@ -117128,8 +116185,10 @@ - (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestC
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestComplexNullableOptionalResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestComplexNullableOptionalRequest::Type request;
@@ -117308,11 +116367,10 @@ new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.
                 }
             }
 
-            auto successFn = Callback<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEchoRequestParams *)params
@@ -117321,8 +116379,10 @@ - (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEcho
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterSimpleStructResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::SimpleStructEchoRequest::Type request;
@@ -117340,11 +116400,10 @@ new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue,
             request.arg1.g = params.arg1.g.floatValue;
             request.arg1.h = params.arg1.h.doubleValue;
 
-            auto successFn = Callback<TestClusterClusterSimpleStructResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)timedInvokeRequestWithCompletion:(MTRStatusCompletion)completion
@@ -117356,12 +116415,13 @@ - (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestPar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TimedInvokeRequest::Type request;
@@ -117374,11 +116434,10 @@ new MTRCommandSuccessCallbackBridge(
                 timedInvokeTimeoutMs.SetValue(10000);
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params
@@ -117386,12 +116445,13 @@ - (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSi
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRCommandSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable value, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type request;
@@ -117407,11 +116467,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
             }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEventRequestParams *)params
@@ -117420,8 +116479,10 @@ - (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEve
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestEmitTestEventResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestEmitTestEventRequest::Type request;
@@ -117434,11 +116495,10 @@ new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQu
             request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
             request.arg3 = params.arg3.boolValue;
 
-            auto successFn = Callback<TestClusterClusterTestEmitTestEventResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)
@@ -117450,8 +116510,10 @@ new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedInvokeTimeoutMs;
             ListFreer listFreer;
             TestCluster::Commands::TestEmitTestFabricScopedEventRequest::Type request;
@@ -117462,23 +116524,22 @@ new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(sel
             }
             request.arg1 = params.arg1.unsignedCharValue;
 
-            auto successFn = Callback<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)readAttributeBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -117493,12 +116554,13 @@ - (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -117510,13 +116572,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -117525,26 +116585,25 @@ - (void)subscribeAttributeBooleanWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -117552,7 +116611,8 @@ + (void)readAttributeBooleanWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
@@ -117561,9 +116621,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -117573,14 +116632,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap8AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap8AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap8AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
-            auto successFn = Callback<TestClusterBitmap8AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -117595,12 +116654,13 @@ - (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -117612,13 +116672,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBitmap8WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -117627,27 +116685,25 @@ - (void)subscribeAttributeBitmap8WithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
-                auto successFn = Callback<TestClusterBitmap8AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap8AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -117655,7 +116711,8 @@ + (void)readAttributeBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap8AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap8AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap8AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
@@ -117664,9 +116721,8 @@ new MTRTestClusterBitmap8AttributeCallbackBridge(queue, completion, ^(Cancelable
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterBitmap8AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -117676,14 +116732,14 @@ new MTRTestClusterBitmap8AttributeCallbackBridge(queue, completion, ^(Cancelable
 
 - (void)readAttributeBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap16AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap16AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap16AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
-            auto successFn = Callback<TestClusterBitmap16AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -117698,12 +116754,13 @@ - (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -117715,13 +116772,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBitmap16WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -117730,27 +116785,25 @@ - (void)subscribeAttributeBitmap16WithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
-                auto successFn = Callback<TestClusterBitmap16AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap16AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -117758,7 +116811,8 @@ + (void)readAttributeBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap16AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap16AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap16AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
@@ -117767,9 +116821,8 @@ new MTRTestClusterBitmap16AttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterBitmap16AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -117779,14 +116832,14 @@ new MTRTestClusterBitmap16AttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap32AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap32AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap32AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
-            auto successFn = Callback<TestClusterBitmap32AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -117801,12 +116854,13 @@ - (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -117818,13 +116872,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBitmap32WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -117833,27 +116885,25 @@ - (void)subscribeAttributeBitmap32WithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
-                auto successFn = Callback<TestClusterBitmap32AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap32AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -117861,7 +116911,8 @@ + (void)readAttributeBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap32AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap32AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap32AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
@@ -117870,9 +116921,8 @@ new MTRTestClusterBitmap32AttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterBitmap32AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -117882,14 +116932,14 @@ new MTRTestClusterBitmap32AttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap64AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap64AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap64AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
-            auto successFn = Callback<TestClusterBitmap64AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -117904,12 +116954,13 @@ - (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -117921,13 +116972,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedLongLongValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeBitmap64WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -117936,27 +116985,25 @@ - (void)subscribeAttributeBitmap64WithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
-                auto successFn = Callback<TestClusterBitmap64AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap64AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -117964,7 +117011,8 @@ + (void)readAttributeBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterBitmap64AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterBitmap64AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap64AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
@@ -117973,9 +117021,8 @@ new MTRTestClusterBitmap64AttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterBitmap64AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -117985,14 +117032,14 @@ new MTRTestClusterBitmap64AttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118007,12 +117054,13 @@ - (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118024,13 +117072,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118039,26 +117085,25 @@ - (void)subscribeAttributeInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118066,7 +117111,8 @@ + (void)readAttributeInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
@@ -118075,9 +117121,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118087,14 +117132,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118109,12 +117154,13 @@ - (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118126,13 +117172,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118141,26 +117185,25 @@ - (void)subscribeAttributeInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118168,7 +117211,8 @@ + (void)readAttributeInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
@@ -118177,9 +117221,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118189,14 +117232,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118211,12 +117254,13 @@ - (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118228,13 +117272,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt24uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118243,26 +117285,25 @@ - (void)subscribeAttributeInt24uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118270,7 +117311,8 @@ + (void)readAttributeInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
@@ -118279,9 +117321,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118291,14 +117332,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118313,12 +117354,13 @@ - (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118330,13 +117372,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt32uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118345,26 +117385,25 @@ - (void)subscribeAttributeInt32uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118372,7 +117411,8 @@ + (void)readAttributeInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
@@ -118381,9 +117421,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118393,14 +117432,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118415,12 +117454,13 @@ - (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118432,13 +117472,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedLongLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt40uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118447,26 +117485,25 @@ - (void)subscribeAttributeInt40uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118474,7 +117511,8 @@ + (void)readAttributeInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
@@ -118483,9 +117521,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118495,14 +117532,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118517,12 +117554,13 @@ - (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118534,13 +117572,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedLongLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt48uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118549,26 +117585,25 @@ - (void)subscribeAttributeInt48uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118576,7 +117611,8 @@ + (void)readAttributeInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
@@ -118585,9 +117621,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118597,14 +117632,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118619,12 +117654,13 @@ - (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118636,13 +117672,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedLongLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt56uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118651,26 +117685,25 @@ - (void)subscribeAttributeInt56uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118678,7 +117711,8 @@ + (void)readAttributeInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
@@ -118687,9 +117721,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118699,14 +117732,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118721,12 +117754,13 @@ - (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118738,13 +117772,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedLongLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt64uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118753,26 +117785,25 @@ - (void)subscribeAttributeInt64uWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118780,7 +117811,8 @@ + (void)readAttributeInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
@@ -118789,9 +117821,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118801,14 +117832,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118823,12 +117854,13 @@ - (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118840,13 +117872,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.charValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118855,26 +117885,25 @@ - (void)subscribeAttributeInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118882,7 +117911,8 @@ + (void)readAttributeInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
@@ -118891,9 +117921,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -118903,14 +117932,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -118925,12 +117954,13 @@ - (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -118942,13 +117972,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -118957,26 +117985,25 @@ - (void)subscribeAttributeInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -118984,7 +118011,8 @@ + (void)readAttributeInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
@@ -118993,9 +118021,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119005,14 +118032,14 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119027,12 +118054,13 @@ - (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119044,13 +118072,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.intValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt24sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119059,26 +118085,25 @@ - (void)subscribeAttributeInt24sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119086,7 +118111,8 @@ + (void)readAttributeInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
@@ -119095,9 +118121,8 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119107,14 +118132,14 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119129,12 +118154,13 @@ - (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119146,13 +118172,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.intValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt32sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119161,26 +118185,25 @@ - (void)subscribeAttributeInt32sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119188,7 +118211,8 @@ + (void)readAttributeInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
@@ -119197,9 +118221,8 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119209,14 +118232,14 @@ new MTRInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119231,12 +118254,13 @@ - (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119248,13 +118272,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.longLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt40sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119263,26 +118285,25 @@ - (void)subscribeAttributeInt40sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119290,7 +118311,8 @@ + (void)readAttributeInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
@@ -119299,9 +118321,8 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119311,14 +118332,14 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119333,12 +118354,13 @@ - (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119350,13 +118372,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.longLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt48sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119365,26 +118385,25 @@ - (void)subscribeAttributeInt48sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119392,7 +118411,8 @@ + (void)readAttributeInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
@@ -119401,9 +118421,8 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119413,14 +118432,14 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119435,12 +118454,13 @@ - (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119452,13 +118472,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.longLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt56sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119467,26 +118485,25 @@ - (void)subscribeAttributeInt56sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119494,7 +118511,8 @@ + (void)readAttributeInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
@@ -119503,9 +118521,8 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119515,14 +118532,14 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119537,12 +118554,13 @@ - (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119554,13 +118572,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.longLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeInt64sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119569,26 +118585,25 @@ - (void)subscribeAttributeInt64sWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119596,7 +118611,8 @@ + (void)readAttributeInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
@@ -119605,9 +118621,8 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119617,14 +118632,14 @@ new MTRInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119639,12 +118654,13 @@ - (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119656,13 +118672,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnum8WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119671,26 +118685,25 @@ - (void)subscribeAttributeEnum8WithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119698,7 +118711,8 @@ + (void)readAttributeEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attri
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
@@ -119707,9 +118721,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119719,14 +118732,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119741,12 +118754,13 @@ - (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119758,13 +118772,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnum16WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119773,26 +118785,25 @@ - (void)subscribeAttributeEnum16WithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119800,7 +118811,8 @@ + (void)readAttributeEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
@@ -119809,9 +118821,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119821,14 +118832,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFloatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFloatAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
-            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119843,12 +118854,13 @@ - (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119860,13 +118872,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.floatValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFloatSingleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119875,26 +118885,25 @@ - (void)subscribeAttributeFloatSingleWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRFloatAttributeCallbackSubscriptionBridge * callbackBridge = new MTRFloatAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFloatAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRFloatAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
-            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRFloatAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -119902,7 +118911,8 @@ + (void)readAttributeFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRFloatAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(FloatAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
@@ -119911,9 +118921,8 @@ new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<FloatAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -119923,14 +118932,14 @@ new MTRFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoubleAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoubleAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoubleAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
-            auto successFn = Callback<DoubleAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -119945,12 +118954,13 @@ - (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -119962,13 +118972,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.doubleValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFloatDoubleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -119977,26 +118985,25 @@ - (void)subscribeAttributeFloatDoubleWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRDoubleAttributeCallbackSubscriptionBridge * callbackBridge = new MTRDoubleAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoubleAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoubleAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRDoubleAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
-            auto successFn = Callback<DoubleAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRDoubleAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120004,7 +119011,8 @@ + (void)readAttributeFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRDoubleAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(DoubleAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
@@ -120013,9 +119021,8 @@ new MTRDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<DoubleAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120025,14 +119032,14 @@ new MTRDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
-            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120047,12 +119054,13 @@ - (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120064,13 +119072,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asByteSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120079,27 +119085,25 @@ - (void)subscribeAttributeOctetStringWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
-                auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120107,7 +119111,8 @@ + (void)readAttributeOctetStringWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(OctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
@@ -120116,9 +119121,8 @@ new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succ
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120128,14 +119132,14 @@ new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succ
 
 - (void)readAttributeListInt8uWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListInt8uListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListInt8uListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterListInt8uListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
-            auto successFn = Callback<TestClusterListInt8uListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120150,12 +119154,13 @@ - (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120188,13 +119193,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeListInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120203,27 +119206,26 @@ - (void)subscribeAttributeListInt8uWithParams:(MTRSubscribeParams * _Nonnull)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
-                auto successFn = Callback<TestClusterListInt8uListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterListInt8uListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeListInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120231,7 +119233,8 @@ + (void)readAttributeListInt8uWithAttributeCache:(MTRAttributeCacheContainer *)a
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListInt8uListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListInt8uListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterListInt8uListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
@@ -120240,9 +119243,8 @@ new MTRTestClusterListInt8uListAttributeCallbackBridge(queue, completion, ^(Canc
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterListInt8uListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120252,14 +119254,14 @@ new MTRTestClusterListInt8uListAttributeCallbackBridge(queue, completion, ^(Canc
 
 - (void)readAttributeListOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListOctetStringListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListOctetStringListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
-            auto successFn = Callback<TestClusterListOctetStringListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120274,12 +119276,13 @@ - (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120312,13 +119315,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeListOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120327,27 +119328,26 @@ - (void)subscribeAttributeListOctetStringWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
-                auto successFn = Callback<TestClusterListOctetStringListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeListOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120355,35 +119355,37 @@ + (void)readAttributeListOctetStringWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterListOctetStringListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterListOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeListStructOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListStructOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
-            auto successFn = Callback<TestClusterListStructOctetStringListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120398,12 +119400,13 @@ - (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120437,13 +119440,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeListStructOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120453,27 +119454,27 @@ - (void)subscribeAttributeListStructOctetStringWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
-                auto successFn = Callback<TestClusterListStructOctetStringListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListStructOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeListStructOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120482,8 +119483,9 @@ + (void)readAttributeListStructOctetStringWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterListStructOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
@@ -120492,9 +119494,8 @@ new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TestClusterListStructOctetStringListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -120504,14 +119505,14 @@ new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(
 
 - (void)readAttributeLongOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
-            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120526,12 +119527,13 @@ - (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120543,13 +119545,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asByteSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLongOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120558,27 +119558,25 @@ - (void)subscribeAttributeLongOctetStringWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTROctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTROctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
-                auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTROctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTROctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTROctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120586,7 +119584,8 @@ + (void)readAttributeLongOctetStringWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTROctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(OctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
@@ -120595,9 +119594,8 @@ new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succ
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<OctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120607,14 +119605,14 @@ new MTROctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succ
 
 - (void)readAttributeCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120629,12 +119627,13 @@ - (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120646,13 +119645,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeCharStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120661,27 +119658,25 @@ - (void)subscribeAttributeCharStringWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120689,7 +119684,8 @@ + (void)readAttributeCharStringWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
@@ -120698,9 +119694,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120710,14 +119705,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeLongCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120732,12 +119727,13 @@ - (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120749,13 +119745,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = [self asCharSpan:value];
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeLongCharStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120764,27 +119758,25 @@ - (void)subscribeAttributeLongCharStringWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
-                auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeLongCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120792,7 +119784,8 @@ + (void)readAttributeLongCharStringWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
@@ -120801,9 +119794,8 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<CharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120813,14 +119805,14 @@ new MTRCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * succe
 
 - (void)readAttributeEpochUsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120835,12 +119827,13 @@ - (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120852,13 +119845,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedLongLongValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEpochUsWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120867,26 +119858,25 @@ - (void)subscribeAttributeEpochUsWithParams:(MTRSubscribeParams * _Nonnull)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt64uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEpochUsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120894,7 +119884,8 @@ + (void)readAttributeEpochUsWithAttributeCache:(MTRAttributeCacheContainer *)att
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
@@ -120903,9 +119894,8 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -120915,14 +119905,14 @@ new MTRInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeEpochSWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -120937,12 +119927,13 @@ - (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -120954,13 +119945,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedIntValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEpochSWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -120969,26 +119958,25 @@ - (void)subscribeAttributeEpochSWithParams:(MTRSubscribeParams * _Nonnull)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEpochSWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -120996,7 +119984,8 @@ + (void)readAttributeEpochSWithAttributeCache:(MTRAttributeCacheContainer *)attr
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
@@ -121005,9 +119994,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121017,14 +120005,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121039,12 +120027,13 @@ - (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121056,13 +120045,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeVendorIdWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121071,26 +120058,25 @@ - (void)subscribeAttributeVendorIdWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRVendorIdAttributeCallbackSubscriptionBridge * callbackBridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRVendorIdAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121098,7 +120084,8 @@ + (void)readAttributeVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
@@ -121107,9 +120094,8 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<VendorIdAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121120,14 +120106,15 @@ new MTRVendorIdAttributeCallbackBridge(queue, completion, ^(Cancelable * success
 - (void)readAttributeListNullablesAndOptionalsStructWithCompletion:(void (^)(NSArray * _Nullable value,
                                                                        NSError * _Nullable error))completion
 {
-    new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListNullablesAndOptionalsStructListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
-            auto successFn = Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121142,12 +120129,13 @@ - (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnu
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121352,13 +120340,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeListNullablesAndOptionalsStructWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121369,28 +120355,28 @@ - (void)subscribeAttributeListNullablesAndOptionalsStructWithParams:(MTRSubscrib
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
-                auto successFn = Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListNullablesAndOptionalsStructListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge
+                = static_cast<MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge * innerCallbackBridge
-                    = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
-                    nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeListNullablesAndOptionalsStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121399,8 +120385,9 @@ + (void)readAttributeListNullablesAndOptionalsStructWithAttributeCache:(MTRAttri
                                                             completion:(void (^)(NSArray * _Nullable value,
                                                                            NSError * _Nullable error))completion
 {
-    new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterListNullablesAndOptionalsStructListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
@@ -121409,9 +120396,8 @@ new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TestClusterListNullablesAndOptionalsStructListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -121421,14 +120407,14 @@ new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(
 
 - (void)readAttributeEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterSimpleEnumAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
-            auto successFn = Callback<TestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121443,12 +120429,13 @@ - (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121460,13 +120447,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeEnumAttrWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121475,27 +120460,26 @@ - (void)subscribeAttributeEnumAttrWithParams:(MTRSubscribeParams * _Nonnull)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
-                auto successFn = Callback<TestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterSimpleEnumAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121503,7 +120487,8 @@ + (void)readAttributeEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)at
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
@@ -121512,9 +120497,8 @@ new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121525,14 +120509,14 @@ new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion, ^(
 - (void)readAttributeStructAttrWithCompletion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                   NSError * _Nullable error))completion
 {
-    new MTRTestClusterStructAttrStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterStructAttrStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterStructAttrStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
-            auto successFn = Callback<TestClusterStructAttrStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _Nonnull)value
@@ -121548,12 +120532,13 @@ - (void)writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121572,13 +120557,11 @@ new MTRDefaultSuccessCallbackBridge(
             cppValue.f = static_cast<std::remove_reference_t<decltype(cppValue.f)>>(value.f.unsignedCharValue);
             cppValue.g = value.g.floatValue;
             cppValue.h = value.h.doubleValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeStructAttrWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121588,27 +120571,26 @@ - (void)subscribeAttributeStructAttrWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
-                auto successFn = Callback<TestClusterStructAttrStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterStructAttrStructAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeStructAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121617,7 +120599,8 @@ + (void)readAttributeStructAttrWithAttributeCache:(MTRAttributeCacheContainer *)
                                        completion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                       NSError * _Nullable error))completion
 {
-    new MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterStructAttrStructAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
@@ -121626,9 +120609,8 @@ new MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterStructAttrStructAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121638,14 +120620,14 @@ new MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121660,12 +120642,13 @@ - (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121677,13 +120660,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRangeRestrictedInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121693,26 +120674,25 @@ - (void)subscribeAttributeRangeRestrictedInt8uWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121721,7 +120701,8 @@ + (void)readAttributeRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
@@ -121730,9 +120711,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121742,14 +120722,14 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121764,12 +120744,13 @@ - (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121781,13 +120762,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.charValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRangeRestrictedInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121797,26 +120776,25 @@ - (void)subscribeAttributeRangeRestrictedInt8sWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121825,7 +120803,8 @@ + (void)readAttributeRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
@@ -121834,9 +120813,8 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121846,14 +120824,14 @@ new MTRInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121868,12 +120846,13 @@ - (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121885,13 +120864,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedShortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRangeRestrictedInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -121901,26 +120878,25 @@ - (void)subscribeAttributeRangeRestrictedInt16uWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -121929,7 +120905,8 @@ + (void)readAttributeRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
@@ -121938,9 +120915,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -121950,14 +120926,14 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -121972,12 +120948,13 @@ - (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -121989,13 +120966,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.shortValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeRangeRestrictedInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122005,26 +120980,25 @@ - (void)subscribeAttributeRangeRestrictedInt16sWithParams:(MTRSubscribeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16sAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122033,7 +121007,8 @@ + (void)readAttributeRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheC
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
@@ -122042,9 +121017,8 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122054,14 +121028,15 @@ new MTRInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeListLongOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListLongOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
-            auto successFn = Callback<TestClusterListLongOctetStringListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -122076,12 +121051,13 @@ - (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122114,13 +121090,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeListLongOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122130,27 +121104,27 @@ - (void)subscribeAttributeListLongOctetStringWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
-                auto successFn = Callback<TestClusterListLongOctetStringListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListLongOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeListLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122159,8 +121133,9 @@ + (void)readAttributeListLongOctetStringWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterListLongOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
@@ -122169,9 +121144,8 @@ new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TestClusterListLongOctetStringListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -122183,15 +121157,15 @@ - (void)readAttributeListFabricScopedWithParams:(MTRReadParams * _Nullable)param
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 { // Make a copy of params before we go async.
     params = [params copy];
-    new MTRTestClusterListFabricScopedListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterListFabricScopedListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListFabricScopedListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
-            auto successFn = Callback<TestClusterListFabricScopedListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(
-                successFn->mContext, successFn->mCall, failureFn->mCall, params.filterByFabric);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -122206,12 +121180,13 @@ - (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122300,13 +121275,11 @@ new MTRDefaultSuccessCallbackBridge(
                     cppValue = ListType_0();
                 }
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeListFabricScopedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122315,27 +121288,27 @@ - (void)subscribeAttributeListFabricScopedWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
-                auto successFn = Callback<TestClusterListFabricScopedListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterListFabricScopedListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeListFabricScopedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122343,35 +121316,36 @@ + (void)readAttributeListFabricScopedWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterListFabricScopedListAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterListFabricScopedListAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeTimedWriteBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -122386,12 +121360,13 @@ - (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122403,13 +121378,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeTimedWriteBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122418,26 +121391,25 @@ - (void)subscribeAttributeTimedWriteBooleanWithParams:(MTRSubscribeParams * _Non
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeTimedWriteBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122445,7 +121417,8 @@ + (void)readAttributeTimedWriteBooleanWithAttributeCache:(MTRAttributeCacheConta
                                                    queue:(dispatch_queue_t)queue
                                               completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
@@ -122454,9 +121427,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122466,14 +121438,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeGeneralErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -122488,12 +121460,13 @@ - (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122505,13 +121478,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneralErrorBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122521,26 +121492,25 @@ - (void)subscribeAttributeGeneralErrorBooleanWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneralErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122549,7 +121519,8 @@ + (void)readAttributeGeneralErrorBooleanWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
@@ -122558,9 +121529,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122570,14 +121540,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -122592,12 +121562,13 @@ - (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122609,13 +121580,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterErrorBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122625,26 +121594,25 @@ - (void)subscribeAttributeClusterErrorBooleanWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122653,7 +121621,8 @@ + (void)readAttributeClusterErrorBooleanWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
@@ -122662,9 +121631,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122674,14 +121642,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeUnsupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -122696,12 +121664,13 @@ - (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122713,13 +121682,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.boolValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeUnsupportedWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122728,26 +121695,25 @@ - (void)subscribeAttributeUnsupportedWithParams:(MTRSubscribeParams * _Nonnull)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRBooleanAttributeCallbackSubscriptionBridge * callbackBridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeUnsupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122755,7 +121721,8 @@ + (void)readAttributeUnsupportedWithAttributeCache:(MTRAttributeCacheContainer *
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
@@ -122764,9 +121731,8 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<BooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122776,14 +121742,14 @@ new MTRBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeNullableBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
-            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -122798,12 +121764,13 @@ - (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122820,13 +121787,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.boolValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableBooleanWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122835,27 +121800,25 @@ - (void)subscribeAttributeNullableBooleanWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableBooleanAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
-                auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableBooleanAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableBooleanAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122863,7 +121826,8 @@ + (void)readAttributeNullableBooleanWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableBooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
@@ -122872,9 +121836,8 @@ new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable *
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableBooleanAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122884,14 +121847,14 @@ new MTRNullableBooleanAttributeCallbackBridge(queue, completion, ^(Cancelable *
 
 - (void)readAttributeNullableBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap8AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap8AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap8AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
-            auto successFn = Callback<TestClusterNullableBitmap8AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -122906,12 +121869,13 @@ - (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -122928,13 +121892,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableBitmap8WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -122943,27 +121905,26 @@ - (void)subscribeAttributeNullableBitmap8WithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
-                auto successFn = Callback<TestClusterNullableBitmap8AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap8AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -122971,7 +121932,8 @@ + (void)readAttributeNullableBitmap8WithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap8AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
@@ -122980,9 +121942,8 @@ new MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, completion, ^(Ca
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterNullableBitmap8AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -122992,14 +121953,14 @@ new MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, completion, ^(Ca
 
 - (void)readAttributeNullableBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap16AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap16AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap16AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
-            auto successFn = Callback<TestClusterNullableBitmap16AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123014,12 +121975,13 @@ - (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123036,13 +121998,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedShortValue);
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableBitmap16WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123051,27 +122011,26 @@ - (void)subscribeAttributeNullableBitmap16WithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
-                auto successFn = Callback<TestClusterNullableBitmap16AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap16AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123079,7 +122038,8 @@ + (void)readAttributeNullableBitmap16WithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap16AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
@@ -123088,9 +122048,8 @@ new MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterNullableBitmap16AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123100,14 +122059,14 @@ new MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeNullableBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap32AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap32AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap32AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
-            auto successFn = Callback<TestClusterNullableBitmap32AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123122,12 +122081,13 @@ - (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123144,13 +122104,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedIntValue);
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableBitmap32WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123159,27 +122117,26 @@ - (void)subscribeAttributeNullableBitmap32WithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
-                auto successFn = Callback<TestClusterNullableBitmap32AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap32AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123187,7 +122144,8 @@ + (void)readAttributeNullableBitmap32WithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap32AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
@@ -123196,9 +122154,8 @@ new MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterNullableBitmap32AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123208,14 +122165,14 @@ new MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeNullableBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap64AttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap64AttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap64AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
-            auto successFn = Callback<TestClusterNullableBitmap64AttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123230,12 +122187,13 @@ - (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123252,13 +122210,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedLongLongValue);
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableBitmap64WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123267,27 +122223,26 @@ - (void)subscribeAttributeNullableBitmap64WithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
-                auto successFn = Callback<TestClusterNullableBitmap64AttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap64AttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123295,7 +122250,8 @@ + (void)readAttributeNullableBitmap64WithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap64AttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
@@ -123304,9 +122260,8 @@ new MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, completion, ^(C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterNullableBitmap64AttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123316,14 +122271,14 @@ new MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, completion, ^(C
 
 - (void)readAttributeNullableInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123338,12 +122293,13 @@ - (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123360,13 +122316,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123375,27 +122329,25 @@ - (void)subscribeAttributeNullableInt8uWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123403,7 +122355,8 @@ + (void)readAttributeNullableInt8uWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
@@ -123412,9 +122365,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123424,14 +122376,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeNullableInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123446,12 +122398,13 @@ - (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123468,13 +122421,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123483,27 +122434,25 @@ - (void)subscribeAttributeNullableInt16uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123511,7 +122460,8 @@ + (void)readAttributeNullableInt16uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
@@ -123520,9 +122470,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123532,14 +122481,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123554,12 +122503,13 @@ - (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123576,13 +122526,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt24uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123591,27 +122539,25 @@ - (void)subscribeAttributeNullableInt24uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123619,7 +122565,8 @@ + (void)readAttributeNullableInt24uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
@@ -123628,9 +122575,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123640,14 +122586,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123662,12 +122608,13 @@ - (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123684,13 +122631,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedIntValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt32uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123699,27 +122644,25 @@ - (void)subscribeAttributeNullableInt32uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
-                auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123727,7 +122670,8 @@ + (void)readAttributeNullableInt32uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
@@ -123736,9 +122680,8 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123748,14 +122691,14 @@ new MTRNullableInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123770,12 +122713,13 @@ - (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123792,13 +122736,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedLongLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt40uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123807,27 +122749,25 @@ - (void)subscribeAttributeNullableInt40uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123835,7 +122775,8 @@ + (void)readAttributeNullableInt40uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
@@ -123844,9 +122785,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123856,14 +122796,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123878,12 +122818,13 @@ - (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -123900,13 +122841,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedLongLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt48uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -123915,27 +122854,25 @@ - (void)subscribeAttributeNullableInt48uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -123943,7 +122880,8 @@ + (void)readAttributeNullableInt48uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
@@ -123952,9 +122890,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -123964,14 +122901,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -123986,12 +122923,13 @@ - (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124008,13 +122946,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedLongLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt56uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124023,27 +122959,25 @@ - (void)subscribeAttributeNullableInt56uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124051,7 +122985,8 @@ + (void)readAttributeNullableInt56uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
@@ -124060,9 +122995,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124072,14 +123006,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124094,12 +123028,13 @@ - (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124116,13 +123051,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedLongLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt64uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124131,27 +123064,25 @@ - (void)subscribeAttributeNullableInt64uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
-                auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124159,7 +123090,8 @@ + (void)readAttributeNullableInt64uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
@@ -124168,9 +123100,8 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124180,14 +123111,14 @@ new MTRNullableInt64uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
-            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124202,12 +123133,13 @@ - (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124224,13 +123156,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.charValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124239,27 +123169,25 @@ - (void)subscribeAttributeNullableInt8sWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
-                auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124267,7 +123195,8 @@ + (void)readAttributeNullableInt8sWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
@@ -124276,9 +123205,8 @@ new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124288,14 +123216,14 @@ new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeNullableInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124310,12 +123238,13 @@ - (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124332,13 +123261,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.shortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124347,27 +123274,25 @@ - (void)subscribeAttributeNullableInt16sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124375,7 +123300,8 @@ + (void)readAttributeNullableInt16sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
@@ -124384,9 +123310,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124396,14 +123321,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
-            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124418,12 +123343,13 @@ - (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124440,13 +123366,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.intValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt24sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124455,27 +123379,25 @@ - (void)subscribeAttributeNullableInt24sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
-                auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124483,7 +123405,8 @@ + (void)readAttributeNullableInt24sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
@@ -124492,9 +123415,8 @@ new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124504,14 +123426,14 @@ new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
-            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124526,12 +123448,13 @@ - (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124548,13 +123471,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.intValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt32sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124563,27 +123484,25 @@ - (void)subscribeAttributeNullableInt32sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt32sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
-                auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt32sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt32sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124591,7 +123510,8 @@ + (void)readAttributeNullableInt32sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt32sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
@@ -124600,9 +123520,8 @@ new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt32sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124612,14 +123531,14 @@ new MTRNullableInt32sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124634,12 +123553,13 @@ - (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124656,13 +123576,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.longLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt40sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124671,27 +123589,25 @@ - (void)subscribeAttributeNullableInt40sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
-                auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124699,7 +123615,8 @@ + (void)readAttributeNullableInt40sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
@@ -124708,9 +123625,8 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124720,14 +123636,14 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124742,12 +123658,13 @@ - (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124764,13 +123681,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.longLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt48sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124779,27 +123694,25 @@ - (void)subscribeAttributeNullableInt48sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
-                auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124807,7 +123720,8 @@ + (void)readAttributeNullableInt48sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
@@ -124816,9 +123730,8 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124828,14 +123741,14 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124850,12 +123763,13 @@ - (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124872,13 +123786,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.longLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt56sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124887,27 +123799,25 @@ - (void)subscribeAttributeNullableInt56sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
-                auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -124915,7 +123825,8 @@ + (void)readAttributeNullableInt56sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
@@ -124924,9 +123835,8 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -124936,14 +123846,14 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -124958,12 +123868,13 @@ - (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -124980,13 +123891,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.longLongValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableInt64sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -124995,27 +123904,25 @@ - (void)subscribeAttributeNullableInt64sWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt64sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
-                auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt64sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125023,7 +123930,8 @@ + (void)readAttributeNullableInt64sWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
@@ -125032,9 +123940,8 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt64sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125044,14 +123951,14 @@ new MTRNullableInt64sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125066,12 +123973,13 @@ - (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125088,13 +123996,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableEnum8WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125103,27 +124009,25 @@ - (void)subscribeAttributeNullableEnum8WithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125131,7 +124035,8 @@ + (void)readAttributeNullableEnum8WithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
@@ -125140,9 +124045,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125152,14 +124056,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeNullableEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125174,12 +124078,13 @@ - (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125196,13 +124101,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableEnum16WithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125211,27 +124114,25 @@ - (void)subscribeAttributeNullableEnum16WithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125239,7 +124140,8 @@ + (void)readAttributeNullableEnum16WithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
@@ -125248,9 +124150,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125260,14 +124161,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableFloatAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableFloatAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableFloatAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
-            auto successFn = Callback<NullableFloatAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125282,12 +124183,13 @@ - (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125304,13 +124206,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.floatValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableFloatSingleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125320,27 +124220,25 @@ - (void)subscribeAttributeNullableFloatSingleWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableFloatAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableFloatAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
-                auto successFn = Callback<NullableFloatAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableFloatAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableFloatAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableFloatAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableFloatAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125349,7 +124247,8 @@ + (void)readAttributeNullableFloatSingleWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableFloatAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableFloatAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
@@ -125358,9 +124257,8 @@ new MTRNullableFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableFloatAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125370,14 +124268,14 @@ new MTRNullableFloatAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 
 - (void)readAttributeNullableFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableDoubleAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableDoubleAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableDoubleAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
-            auto successFn = Callback<NullableDoubleAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125392,12 +124290,13 @@ - (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125414,13 +124313,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.doubleValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableFloatDoubleWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125430,27 +124327,25 @@ - (void)subscribeAttributeNullableFloatDoubleWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableDoubleAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableDoubleAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
-                auto successFn = Callback<NullableDoubleAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableDoubleAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableDoubleAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableDoubleAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableDoubleAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125459,7 +124354,8 @@ + (void)readAttributeNullableFloatDoubleWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableDoubleAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableDoubleAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
@@ -125468,9 +124364,8 @@ new MTRNullableDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableDoubleAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125480,14 +124375,14 @@ new MTRNullableDoubleAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeNullableOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125502,12 +124397,13 @@ - (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125524,13 +124420,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = [self asByteSpan:value];
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableOctetStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125539,27 +124433,25 @@ - (void)subscribeAttributeNullableOctetStringWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableOctetStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
-                auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableOctetStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125567,7 +124459,8 @@ + (void)readAttributeNullableOctetStringWithAttributeCache:(MTRAttributeCacheCon
                                                      queue:(dispatch_queue_t)queue
                                                 completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
@@ -125576,9 +124469,8 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableOctetStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125588,14 +124480,14 @@ new MTRNullableOctetStringAttributeCallbackBridge(queue, completion, ^(Cancelabl
 
 - (void)readAttributeNullableCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
-            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125610,12 +124502,13 @@ - (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125632,13 +124525,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = [self asCharSpan:value];
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableCharStringWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125648,27 +124539,25 @@ - (void)subscribeAttributeNullableCharStringWithParams:(MTRSubscribeParams * _No
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableCharStringAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
-                auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableCharStringAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableCharStringAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125677,7 +124566,8 @@ + (void)readAttributeNullableCharStringWithAttributeCache:(MTRAttributeCacheCont
                                                completion:
                                                    (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableCharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
@@ -125686,9 +124576,8 @@ new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableCharStringAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -125698,14 +124587,15 @@ new MTRNullableCharStringAttributeCallbackBridge(queue, completion, ^(Cancelable
 
 - (void)readAttributeNullableEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableTestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
-            auto successFn = Callback<NullableTestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125720,12 +124610,13 @@ - (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125742,13 +124633,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableEnumAttrWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125757,27 +124646,27 @@ - (void)subscribeAttributeNullableEnumAttrWithParams:(MTRSubscribeParams * _Nonn
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
-                auto successFn = Callback<NullableTestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            NullableTestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125785,8 +124674,9 @@ + (void)readAttributeNullableEnumAttrWithAttributeCache:(MTRAttributeCacheContai
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(NullableTestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
@@ -125795,9 +124685,8 @@ new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<NullableTestClusterClusterSimpleEnumAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -125808,14 +124697,15 @@ new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(
 - (void)readAttributeNullableStructWithCompletion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                       NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableStructStructAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterNullableStructStructAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterNullableStructStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
-            auto successFn = Callback<TestClusterNullableStructStructAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct * _Nullable)value
@@ -125833,12 +124723,13 @@ - (void)writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125862,13 +124753,11 @@ new MTRDefaultSuccessCallbackBridge(
                 nonNullValue_0.g = value.g.floatValue;
                 nonNullValue_0.h = value.h.doubleValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableStructWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125878,27 +124767,27 @@ - (void)subscribeAttributeNullableStructWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
-                auto successFn = Callback<TestClusterNullableStructStructAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterNullableStructStructAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -125907,36 +124796,37 @@ + (void)readAttributeNullableStructWithAttributeCache:(MTRAttributeCacheContaine
                                            completion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                           NSError * _Nullable error))completion
 {
-    new MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
-        if (attributeCacheContainer.cppAttributeCache) {
-            chip::app::ConcreteAttributePath path;
-            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
-            path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
-            path.mClusterId = TypeInfo::GetClusterId();
-            path.mAttributeId = TypeInfo::GetAttributeId();
-            TypeInfo::DecodableType value;
-            CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterNullableStructStructAttributeCallback>::FromCancelable(success);
-            if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+    auto * bridge = new MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterNullableStructStructAttributeCallback successCb, MTRErrorCallback failureCb) {
+            if (attributeCacheContainer.cppAttributeCache) {
+                chip::app::ConcreteAttributePath path;
+                using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
+                path.mEndpointId = static_cast<chip::EndpointId>([endpoint unsignedShortValue]);
+                path.mClusterId = TypeInfo::GetClusterId();
+                path.mAttributeId = TypeInfo::GetAttributeId();
+                TypeInfo::DecodableType value;
+                CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
+                if (err == CHIP_NO_ERROR) {
+                    successCb(bridge, value);
+                }
+                return err;
             }
-            return err;
-        }
-        return CHIP_ERROR_NOT_FOUND;
-    });
+            return CHIP_ERROR_NOT_FOUND;
+        });
 }
 
 - (void)readAttributeNullableRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -125951,12 +124841,13 @@ - (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullabl
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -125973,13 +124864,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedCharValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableRangeRestrictedInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -125990,27 +124879,25 @@ - (void)subscribeAttributeNullableRangeRestrictedInt8uWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
-                auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126019,7 +124906,8 @@ + (void)readAttributeNullableRangeRestrictedInt8uWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
@@ -126028,9 +124916,8 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126041,14 +124928,14 @@ new MTRNullableInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 - (void)readAttributeNullableRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
 {
-    new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
-            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -126063,12 +124950,13 @@ - (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullabl
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -126085,13 +124973,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.charValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableRangeRestrictedInt8sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126102,27 +124988,25 @@ - (void)subscribeAttributeNullableRangeRestrictedInt8sWithParams:(MTRSubscribePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt8sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
-                auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt8sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt8sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126131,7 +125015,8 @@ + (void)readAttributeNullableRangeRestrictedInt8sWithAttributeCache:(MTRAttribut
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
 {
-    new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt8sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
@@ -126140,9 +125025,8 @@ new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * su
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt8sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126153,14 +125037,14 @@ new MTRNullableInt8sAttributeCallbackBridge(queue, completion, ^(Cancelable * su
 - (void)readAttributeNullableRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -126175,12 +125059,13 @@ - (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullab
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -126197,13 +125082,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.unsignedShortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableRangeRestrictedInt16uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126214,27 +125097,25 @@ - (void)subscribeAttributeNullableRangeRestrictedInt16uWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16uAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
-                auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126243,7 +125124,8 @@ + (void)readAttributeNullableRangeRestrictedInt16uWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
@@ -126252,9 +125134,8 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126265,14 +125146,14 @@ new MTRNullableInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 - (void)readAttributeNullableRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
@@ -126287,12 +125168,13 @@ - (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullab
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -126309,13 +125191,11 @@ new MTRDefaultSuccessCallbackBridge(
                 auto & nonNullValue_0 = cppValue.SetNonNull();
                 nonNullValue_0 = value.shortValue;
             }
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeNullableRangeRestrictedInt16sWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126326,27 +125206,25 @@ - (void)subscribeAttributeNullableRangeRestrictedInt16sWithParams:(MTRSubscribeP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRNullableInt16sAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
-                auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRNullableInt16sAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                    !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
+                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeNullableRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126355,7 +125233,8 @@ + (void)readAttributeNullableRangeRestrictedInt16sWithAttributeCache:(MTRAttribu
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
 {
-    new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
@@ -126364,9 +125243,8 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<NullableInt16sAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126376,14 +125254,14 @@ new MTRNullableInt16sAttributeCallbackBridge(queue, completion, ^(Cancelable * s
 
 - (void)readAttributeWriteOnlyInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
@@ -126398,12 +125276,13 @@ - (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue, self.device,
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(
+        self.callbackQueue,
         ^(id _Nullable ignored, NSError * _Nullable error) {
             completion(error);
         },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             chip::Optional<uint16_t> timedWriteTimeout;
             if (params != nil) {
                 if (params.timedWriteTimeout != nil) {
@@ -126415,13 +125294,11 @@ new MTRDefaultSuccessCallbackBridge(
             using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
             TypeInfo::Type cppValue;
             cppValue = value.unsignedCharValue;
-            auto successFn = Callback<DefaultSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(
-                cppValue, successFn->mContext, successFn->mCall, failureFn->mCall, timedWriteTimeout);
+            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeWriteOnlyInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126430,26 +125307,25 @@ - (void)subscribeAttributeWriteOnlyInt8uWithParams:(MTRSubscribeParams * _Nonnul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt8uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt8uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeWriteOnlyInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126457,7 +125333,8 @@ + (void)readAttributeWriteOnlyInt8uWithAttributeCache:(MTRAttributeCacheContaine
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
@@ -126466,9 +125343,8 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int8uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126478,14 +125354,15 @@ new MTRInt8uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, C
 
 - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
-            auto successFn = Callback<TestClusterGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126495,27 +125372,27 @@ - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
-                auto successFn = Callback<TestClusterGeneratedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126524,8 +125401,9 @@ + (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheCo
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
@@ -126534,9 +125412,8 @@ new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TestClusterGeneratedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -126546,14 +125423,15 @@ new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
-            auto successFn = Callback<TestClusterAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126563,27 +125441,27 @@ - (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
-                auto successFn = Callback<TestClusterAcceptedCommandListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+            TestClusterAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
+            MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126592,8 +125470,9 @@ + (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheCon
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(
-        queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(
+        ^(TestClusterAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
             if (attributeCacheContainer.cppAttributeCache) {
                 chip::app::ConcreteAttributePath path;
                 using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
@@ -126602,9 +125481,8 @@ new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(
                 path.mAttributeId = TypeInfo::GetAttributeId();
                 TypeInfo::DecodableType value;
                 CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-                auto successFn = Callback<TestClusterAcceptedCommandListListAttributeCallback>::FromCancelable(success);
                 if (err == CHIP_NO_ERROR) {
-                    successFn->mCall(successFn->mContext, value);
+                    successCb(bridge, value);
                 }
                 return err;
             }
@@ -126614,14 +125492,14 @@ new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(
 
 - (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterAttributeListListAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
-            auto successFn = Callback<TestClusterAttributeListListAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126630,27 +125508,26 @@ - (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge * callbackBridge
-        = new MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(
-            self.callbackQueue, self.device, reportHandler,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                if (!params.resubscribeIfLost) {
-                    // We don't support disabling auto-resubscribe.
-                    return CHIP_ERROR_INVALID_ARGUMENT;
-                }
-                using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
-                auto successFn = Callback<TestClusterAttributeListListAttributeCallback>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+    auto * bridge = new MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterAttributeListListAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
+            if (!params.resubscribeIfLost) {
+                // We don't support disabling auto-resubscribe.
+                return CHIP_ERROR_INVALID_ARGUMENT;
+            }
+            using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
 
-                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-                return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                    [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                    MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
-                    params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
-                    [innerCallbackBridge](void) { delete innerCallbackBridge; });
-            },
-            subscriptionEstablished);
+            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue],
+                MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
+                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
+        },
+        subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126658,7 +125535,8 @@ + (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRTestClusterAttributeListListAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRTestClusterAttributeListListAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(TestClusterAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
@@ -126667,9 +125545,8 @@ new MTRTestClusterAttributeListListAttributeCallbackBridge(queue, completion, ^(
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<TestClusterAttributeListListAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126679,14 +125556,14 @@ new MTRTestClusterAttributeListListAttributeCallbackBridge(queue, completion, ^(
 
 - (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126695,26 +125572,25 @@ - (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt32uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt32uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126722,7 +125598,8 @@ + (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
@@ -126731,9 +125608,8 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int32uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
@@ -126743,14 +125619,14 @@ new MTRInt32uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
 
 - (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(self.callbackQueue, self.device, completion,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
             using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.ReadAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall);
+            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
         });
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
@@ -126759,26 +125635,25 @@ - (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    __block MTRInt16uAttributeCallbackSubscriptionBridge * callbackBridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
-        self.callbackQueue, self.device, reportHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
+        self.callbackQueue, reportHandler,
+        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
+            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
             if (!params.resubscribeIfLost) {
                 // We don't support disabling auto-resubscribe.
                 return CHIP_ERROR_INVALID_ARGUMENT;
             }
             using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
 
             chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            MTRInt16uAttributeCallbackSubscriptionBridge * innerCallbackBridge = callbackBridge;
-            return cppCluster.SubscribeAttribute<TypeInfo>(successFn->mContext, successFn->mCall, failureFn->mCall,
-                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
-                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
-                !params.replaceExistingSubscriptions, chip::NullOptional,
-                [innerCallbackBridge](void) { delete innerCallbackBridge; });
+            return cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb, [params.minInterval unsignedShortValue],
+                [params.maxInterval unsignedShortValue], MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
+                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
+                [typedBridge](void) { delete typedBridge; });
         },
         subscriptionEstablished);
+    std::move(*bridge).DispatchAction(self.device);
 }
 
 + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
@@ -126786,7 +125661,8 @@ + (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContain
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
 {
-    new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success, Cancelable * failure) {
+    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
+    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
         if (attributeCacheContainer.cppAttributeCache) {
             chip::app::ConcreteAttributePath path;
             using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
@@ -126795,9 +125671,8 @@ new MTRInt16uAttributeCallbackBridge(queue, completion, ^(Cancelable * success,
             path.mAttributeId = TypeInfo::GetAttributeId();
             TypeInfo::DecodableType value;
             CHIP_ERROR err = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
-            auto successFn = Callback<Int16uAttributeCallback>::FromCancelable(success);
             if (err == CHIP_NO_ERROR) {
-                successFn->mCall(successFn->mContext, value);
+                successCb(bridge, value);
             }
             return err;
         }
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge_internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge_internal.h
index fe1c002b40ad80..5bd5d631189878 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge_internal.h
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge_internal.h
@@ -1114,17 +1114,12 @@ typedef void (*TestClusterAttributeListListAttributeCallback)(void * context,
 class MTRDefaultSuccessCallbackBridge : public MTRCallbackBridge<DefaultSuccessCallback>
 {
 public:
-    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                    bool keepAlive = false) :
-        MTRCallbackBridge<DefaultSuccessCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DefaultSuccessCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DefaultSuccessCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
-        MTRCallbackBridge<DefaultSuccessCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<DefaultSuccessCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context);
 };
@@ -1132,17 +1127,12 @@ class MTRDefaultSuccessCallbackBridge : public MTRCallbackBridge<DefaultSuccessC
 class MTRCommandSuccessCallbackBridge : public MTRCallbackBridge<CommandSuccessCallback>
 {
 public:
-    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                    bool keepAlive = false) :
-        MTRCallbackBridge<CommandSuccessCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<CommandSuccessCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<CommandSuccessCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
-        MTRCallbackBridge<CommandSuccessCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<CommandSuccessCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::NullObjectType &);
 };
@@ -1150,34 +1140,22 @@ class MTRCommandSuccessCallbackBridge : public MTRCallbackBridge<CommandSuccessC
 class MTROctetStringAttributeCallbackBridge : public MTRCallbackBridge<OctetStringAttributeCallback>
 {
 public:
-    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<OctetStringAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                           bool keepAlive = false) :
         MTRCallbackBridge<OctetStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                          ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OctetStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OctetStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::ByteSpan value);
 };
 
 class MTROctetStringAttributeCallbackSubscriptionBridge : public MTROctetStringAttributeCallbackBridge
 {
 public:
-    MTROctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action,
+    MTROctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROctetStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROctetStringAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROctetStringAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1190,37 +1168,23 @@ class MTROctetStringAttributeCallbackSubscriptionBridge : public MTROctetStringA
 class MTRNullableOctetStringAttributeCallbackBridge : public MTRCallbackBridge<NullableOctetStringAttributeCallback>
 {
 public:
-    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                   bool keepAlive = false) :
         MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                keepAlive){};
-
-    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::ByteSpan> & value);
 };
 
 class MTRNullableOctetStringAttributeCallbackSubscriptionBridge : public MTRNullableOctetStringAttributeCallbackBridge
 {
 public:
-    MTRNullableOctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableOctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOctetStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOctetStringAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOctetStringAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1233,34 +1197,22 @@ class MTRNullableOctetStringAttributeCallbackSubscriptionBridge : public MTRNull
 class MTRCharStringAttributeCallbackBridge : public MTRCallbackBridge<CharStringAttributeCallback>
 {
 public:
-    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<CharStringAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                          bool keepAlive = false) :
         MTRCallbackBridge<CharStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                         ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<CharStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<CharStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::CharSpan value);
 };
 
 class MTRCharStringAttributeCallbackSubscriptionBridge : public MTRCharStringAttributeCallbackBridge
 {
 public:
-    MTRCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                     ResponseHandler handler, MTRActionBlock action,
+    MTRCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRCharStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                     MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRCharStringAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRCharStringAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1273,37 +1225,22 @@ class MTRCharStringAttributeCallbackSubscriptionBridge : public MTRCharStringAtt
 class MTRNullableCharStringAttributeCallbackBridge : public MTRCallbackBridge<NullableCharStringAttributeCallback>
 {
 public:
-    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  bool keepAlive = false) :
         MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                               keepAlive){};
-
-    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::CharSpan> & value);
 };
 
 class MTRNullableCharStringAttributeCallbackSubscriptionBridge : public MTRNullableCharStringAttributeCallbackBridge
 {
 public:
-    MTRNullableCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action,
-                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableCharStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRNullableCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableCharStringAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableCharStringAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1316,34 +1253,22 @@ class MTRNullableCharStringAttributeCallbackSubscriptionBridge : public MTRNulla
 class MTRBooleanAttributeCallbackBridge : public MTRCallbackBridge<BooleanAttributeCallback>
 {
 public:
-    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<BooleanAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                       bool keepAlive = false) :
         MTRCallbackBridge<BooleanAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, bool value);
 };
 
 class MTRBooleanAttributeCallbackSubscriptionBridge : public MTRBooleanAttributeCallbackBridge
 {
 public:
-    MTRBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                  ResponseHandler handler, MTRActionBlock action,
+    MTRBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                  MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBooleanAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1356,36 +1281,22 @@ class MTRBooleanAttributeCallbackSubscriptionBridge : public MTRBooleanAttribute
 class MTRNullableBooleanAttributeCallbackBridge : public MTRCallbackBridge<NullableBooleanAttributeCallback>
 {
 public:
-    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                               bool keepAlive = false) :
         MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                              ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                              MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<bool> & value);
 };
 
 class MTRNullableBooleanAttributeCallbackSubscriptionBridge : public MTRNullableBooleanAttributeCallbackBridge
 {
 public:
-    MTRNullableBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action,
-                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableBooleanAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action,
+    MTRNullableBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableBooleanAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableBooleanAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1398,17 +1309,12 @@ class MTRNullableBooleanAttributeCallbackSubscriptionBridge : public MTRNullable
 class MTRInt8uAttributeCallbackBridge : public MTRCallbackBridge<Int8uAttributeCallback>
 {
 public:
-    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                    bool keepAlive = false) :
-        MTRCallbackBridge<Int8uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int8uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int8uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int8uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int8uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, uint8_t value);
 };
@@ -1416,16 +1322,9 @@ class MTRInt8uAttributeCallbackBridge : public MTRCallbackBridge<Int8uAttributeC
 class MTRInt8uAttributeCallbackSubscriptionBridge : public MTRInt8uAttributeCallbackBridge
 {
 public:
-    MTRInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                ResponseHandler handler, MTRActionBlock action,
+    MTRInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt8uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt8uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt8uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1438,36 +1337,22 @@ class MTRInt8uAttributeCallbackSubscriptionBridge : public MTRInt8uAttributeCall
 class MTRNullableInt8uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt8uAttributeCallback>
 {
 public:
-    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                             bool keepAlive = false) :
         MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                            ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint8_t> & value);
 };
 
 class MTRNullableInt8uAttributeCallbackSubscriptionBridge : public MTRNullableInt8uAttributeCallbackBridge
 {
 public:
-    MTRNullableInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action,
-                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt8uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action,
+    MTRNullableInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt8uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt8uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1480,17 +1365,12 @@ class MTRNullableInt8uAttributeCallbackSubscriptionBridge : public MTRNullableIn
 class MTRInt8sAttributeCallbackBridge : public MTRCallbackBridge<Int8sAttributeCallback>
 {
 public:
-    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                    bool keepAlive = false) :
-        MTRCallbackBridge<Int8sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int8sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int8sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int8sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int8sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, int8_t value);
 };
@@ -1498,16 +1378,9 @@ class MTRInt8sAttributeCallbackBridge : public MTRCallbackBridge<Int8sAttributeC
 class MTRInt8sAttributeCallbackSubscriptionBridge : public MTRInt8sAttributeCallbackBridge
 {
 public:
-    MTRInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                ResponseHandler handler, MTRActionBlock action,
+    MTRInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt8sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt8sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt8sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1520,36 +1393,22 @@ class MTRInt8sAttributeCallbackSubscriptionBridge : public MTRInt8sAttributeCall
 class MTRNullableInt8sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt8sAttributeCallback>
 {
 public:
-    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                             bool keepAlive = false) :
         MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                            ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int8_t> & value);
 };
 
 class MTRNullableInt8sAttributeCallbackSubscriptionBridge : public MTRNullableInt8sAttributeCallbackBridge
 {
 public:
-    MTRNullableInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action,
-                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt8sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action,
+    MTRNullableInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt8sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt8sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1562,17 +1421,12 @@ class MTRNullableInt8sAttributeCallbackSubscriptionBridge : public MTRNullableIn
 class MTRInt16uAttributeCallbackBridge : public MTRCallbackBridge<Int16uAttributeCallback>
 {
 public:
-    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int16uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int16uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int16uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<Int16uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int16uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, uint16_t value);
 };
@@ -1580,16 +1434,9 @@ class MTRInt16uAttributeCallbackBridge : public MTRCallbackBridge<Int16uAttribut
 class MTRInt16uAttributeCallbackSubscriptionBridge : public MTRInt16uAttributeCallbackBridge
 {
 public:
-    MTRInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt16uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt16uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt16uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1602,36 +1449,22 @@ class MTRInt16uAttributeCallbackSubscriptionBridge : public MTRInt16uAttributeCa
 class MTRNullableInt16uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt16uAttributeCallback>
 {
 public:
-    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint16_t> & value);
 };
 
 class MTRNullableInt16uAttributeCallbackSubscriptionBridge : public MTRNullableInt16uAttributeCallbackBridge
 {
 public:
-    MTRNullableInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt16uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt16uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt16uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1644,17 +1477,12 @@ class MTRNullableInt16uAttributeCallbackSubscriptionBridge : public MTRNullableI
 class MTRInt16sAttributeCallbackBridge : public MTRCallbackBridge<Int16sAttributeCallback>
 {
 public:
-    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int16sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int16sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int16sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<Int16sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int16sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, int16_t value);
 };
@@ -1662,16 +1490,9 @@ class MTRInt16sAttributeCallbackBridge : public MTRCallbackBridge<Int16sAttribut
 class MTRInt16sAttributeCallbackSubscriptionBridge : public MTRInt16sAttributeCallbackBridge
 {
 public:
-    MTRInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt16sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt16sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt16sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1684,36 +1505,22 @@ class MTRInt16sAttributeCallbackSubscriptionBridge : public MTRInt16sAttributeCa
 class MTRNullableInt16sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt16sAttributeCallback>
 {
 public:
-    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int16_t> & value);
 };
 
 class MTRNullableInt16sAttributeCallbackSubscriptionBridge : public MTRNullableInt16sAttributeCallbackBridge
 {
 public:
-    MTRNullableInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt16sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt16sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt16sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1726,17 +1533,12 @@ class MTRNullableInt16sAttributeCallbackSubscriptionBridge : public MTRNullableI
 class MTRInt32uAttributeCallbackBridge : public MTRCallbackBridge<Int32uAttributeCallback>
 {
 public:
-    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int32uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int32uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int32uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<Int32uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int32uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, uint32_t value);
 };
@@ -1744,16 +1546,9 @@ class MTRInt32uAttributeCallbackBridge : public MTRCallbackBridge<Int32uAttribut
 class MTRInt32uAttributeCallbackSubscriptionBridge : public MTRInt32uAttributeCallbackBridge
 {
 public:
-    MTRInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt32uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt32uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt32uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1766,36 +1561,22 @@ class MTRInt32uAttributeCallbackSubscriptionBridge : public MTRInt32uAttributeCa
 class MTRNullableInt32uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt32uAttributeCallback>
 {
 public:
-    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint32_t> & value);
 };
 
 class MTRNullableInt32uAttributeCallbackSubscriptionBridge : public MTRNullableInt32uAttributeCallbackBridge
 {
 public:
-    MTRNullableInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt32uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt32uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt32uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1808,17 +1589,12 @@ class MTRNullableInt32uAttributeCallbackSubscriptionBridge : public MTRNullableI
 class MTRInt32sAttributeCallbackBridge : public MTRCallbackBridge<Int32sAttributeCallback>
 {
 public:
-    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int32sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int32sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int32sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<Int32sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int32sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, int32_t value);
 };
@@ -1826,16 +1602,9 @@ class MTRInt32sAttributeCallbackBridge : public MTRCallbackBridge<Int32sAttribut
 class MTRInt32sAttributeCallbackSubscriptionBridge : public MTRInt32sAttributeCallbackBridge
 {
 public:
-    MTRInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt32sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt32sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt32sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1848,36 +1617,22 @@ class MTRInt32sAttributeCallbackSubscriptionBridge : public MTRInt32sAttributeCa
 class MTRNullableInt32sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt32sAttributeCallback>
 {
 public:
-    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int32_t> & value);
 };
 
 class MTRNullableInt32sAttributeCallbackSubscriptionBridge : public MTRNullableInt32sAttributeCallbackBridge
 {
 public:
-    MTRNullableInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt32sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt32sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt32sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1890,17 +1645,12 @@ class MTRNullableInt32sAttributeCallbackSubscriptionBridge : public MTRNullableI
 class MTRInt64uAttributeCallbackBridge : public MTRCallbackBridge<Int64uAttributeCallback>
 {
 public:
-    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int64uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int64uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int64uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<Int64uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int64uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, uint64_t value);
 };
@@ -1908,16 +1658,9 @@ class MTRInt64uAttributeCallbackBridge : public MTRCallbackBridge<Int64uAttribut
 class MTRInt64uAttributeCallbackSubscriptionBridge : public MTRInt64uAttributeCallbackBridge
 {
 public:
-    MTRInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt64uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt64uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt64uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1930,36 +1673,22 @@ class MTRInt64uAttributeCallbackSubscriptionBridge : public MTRInt64uAttributeCa
 class MTRNullableInt64uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt64uAttributeCallback>
 {
 public:
-    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint64_t> & value);
 };
 
 class MTRNullableInt64uAttributeCallbackSubscriptionBridge : public MTRNullableInt64uAttributeCallbackBridge
 {
 public:
-    MTRNullableInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt64uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt64uAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt64uAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -1972,17 +1701,12 @@ class MTRNullableInt64uAttributeCallbackSubscriptionBridge : public MTRNullableI
 class MTRInt64sAttributeCallbackBridge : public MTRCallbackBridge<Int64sAttributeCallback>
 {
 public:
-    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<Int64sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<Int64sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<Int64sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<Int64sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<Int64sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, int64_t value);
 };
@@ -1990,16 +1714,9 @@ class MTRInt64sAttributeCallbackBridge : public MTRCallbackBridge<Int64sAttribut
 class MTRInt64sAttributeCallbackSubscriptionBridge : public MTRInt64sAttributeCallbackBridge
 {
 public:
-    MTRInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt64sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRInt64sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRInt64sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2012,36 +1729,22 @@ class MTRInt64sAttributeCallbackSubscriptionBridge : public MTRInt64sAttributeCa
 class MTRNullableInt64sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt64sAttributeCallback>
 {
 public:
-    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int64_t> & value);
 };
 
 class MTRNullableInt64sAttributeCallbackSubscriptionBridge : public MTRNullableInt64sAttributeCallbackBridge
 {
 public:
-    MTRNullableInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt64sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableInt64sAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableInt64sAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2054,17 +1757,12 @@ class MTRNullableInt64sAttributeCallbackSubscriptionBridge : public MTRNullableI
 class MTRFloatAttributeCallbackBridge : public MTRCallbackBridge<FloatAttributeCallback>
 {
 public:
-    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                    bool keepAlive = false) :
-        MTRCallbackBridge<FloatAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FloatAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<FloatAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
-        MTRCallbackBridge<FloatAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<FloatAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, float value);
 };
@@ -2072,16 +1770,9 @@ class MTRFloatAttributeCallbackBridge : public MTRCallbackBridge<FloatAttributeC
 class MTRFloatAttributeCallbackSubscriptionBridge : public MTRFloatAttributeCallbackBridge
 {
 public:
-    MTRFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                ResponseHandler handler, MTRActionBlock action,
+    MTRFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFloatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFloatAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFloatAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2094,36 +1785,22 @@ class MTRFloatAttributeCallbackSubscriptionBridge : public MTRFloatAttributeCall
 class MTRNullableFloatAttributeCallbackBridge : public MTRCallbackBridge<NullableFloatAttributeCallback>
 {
 public:
-    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableFloatAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                             bool keepAlive = false) :
         MTRCallbackBridge<NullableFloatAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                            ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFloatAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFloatAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<float> & value);
 };
 
 class MTRNullableFloatAttributeCallbackSubscriptionBridge : public MTRNullableFloatAttributeCallbackBridge
 {
 public:
-    MTRNullableFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action,
-                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFloatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action,
+    MTRNullableFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFloatAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableFloatAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2136,17 +1813,12 @@ class MTRNullableFloatAttributeCallbackSubscriptionBridge : public MTRNullableFl
 class MTRDoubleAttributeCallbackBridge : public MTRCallbackBridge<DoubleAttributeCallback>
 {
 public:
-    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
-                                     bool keepAlive = false) :
-        MTRCallbackBridge<DoubleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoubleAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoubleAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                      bool keepAlive = false) :
-        MTRCallbackBridge<DoubleAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<DoubleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, double value);
 };
@@ -2154,16 +1826,9 @@ class MTRDoubleAttributeCallbackBridge : public MTRCallbackBridge<DoubleAttribut
 class MTRDoubleAttributeCallbackSubscriptionBridge : public MTRDoubleAttributeCallbackBridge
 {
 public:
-    MTRDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action,
+    MTRDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoubleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoubleAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoubleAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2176,36 +1841,22 @@ class MTRDoubleAttributeCallbackSubscriptionBridge : public MTRDoubleAttributeCa
 class MTRNullableDoubleAttributeCallbackBridge : public MTRCallbackBridge<NullableDoubleAttributeCallback>
 {
 public:
-    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<double> & value);
 };
 
 class MTRNullableDoubleAttributeCallbackSubscriptionBridge : public MTRNullableDoubleAttributeCallbackBridge
 {
 public:
-    MTRNullableDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action,
-                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoubleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action,
+    MTRNullableDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoubleAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoubleAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2218,34 +1869,22 @@ class MTRNullableDoubleAttributeCallbackSubscriptionBridge : public MTRNullableD
 class MTRVendorIdAttributeCallbackBridge : public MTRCallbackBridge<VendorIdAttributeCallback>
 {
 public:
-    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<VendorIdAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                        bool keepAlive = false) :
         MTRCallbackBridge<VendorIdAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                       ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<VendorIdAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<VendorIdAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::VendorId value);
 };
 
 class MTRVendorIdAttributeCallbackSubscriptionBridge : public MTRVendorIdAttributeCallbackBridge
 {
 public:
-    MTRVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                   ResponseHandler handler, MTRActionBlock action,
+    MTRVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRVendorIdAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                   MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRVendorIdAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRVendorIdAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2258,36 +1897,22 @@ class MTRVendorIdAttributeCallbackSubscriptionBridge : public MTRVendorIdAttribu
 class MTRNullableVendorIdAttributeCallbackBridge : public MTRCallbackBridge<NullableVendorIdAttributeCallback>
 {
 public:
-    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                bool keepAlive = false) :
         MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                               ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::VendorId> & value);
 };
 
 class MTRNullableVendorIdAttributeCallbackSubscriptionBridge : public MTRNullableVendorIdAttributeCallbackBridge
 {
 public:
-    MTRNullableVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action,
-                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableVendorIdAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action,
+    MTRNullableVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableVendorIdAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableVendorIdAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2302,20 +1927,12 @@ class MTRIdentifyGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2324,18 +1941,10 @@ class MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRIdentifyGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2350,20 +1959,12 @@ class MTRIdentifyAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2372,18 +1973,10 @@ class MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRIdentifyAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2396,38 +1989,23 @@ class MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRIdentifyAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>
 {
 public:
-    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge : public MTRIdentifyAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIdentifyAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2442,20 +2020,12 @@ class MTRGroupsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2464,18 +2034,10 @@ class MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRGroupsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2490,18 +2052,12 @@ class MTRGroupsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2510,18 +2066,10 @@ class MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRGroupsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2534,37 +2082,23 @@ class MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRGroupsAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<GroupsAttributeListListAttributeCallback>
 {
 public:
-    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge : public MTRGroupsAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2579,20 +2113,12 @@ class MTRScenesGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2601,18 +2127,10 @@ class MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRScenesGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2627,18 +2145,12 @@ class MTRScenesAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2647,18 +2159,10 @@ class MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRScenesAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2671,37 +2175,23 @@ class MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRScenesAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ScenesAttributeListListAttributeCallback>
 {
 public:
-    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRScenesAttributeListListAttributeCallbackSubscriptionBridge : public MTRScenesAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRScenesAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRScenesAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRScenesAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2716,18 +2206,12 @@ class MTROnOffGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2736,18 +2220,10 @@ class MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTROnOffGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2762,18 +2238,12 @@ class MTROnOffAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2782,18 +2252,10 @@ class MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTROnOffAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2806,37 +2268,23 @@ class MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTROnOffAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<OnOffAttributeListListAttributeCallback>
 {
 public:
-    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                      bool keepAlive = false) :
         MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                   keepAlive){};
-
-    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTROnOffAttributeListListAttributeCallbackSubscriptionBridge : public MTROnOffAttributeListListAttributeCallbackBridge
 {
 public:
-    MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2851,22 +2299,14 @@ class MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2876,17 +2316,9 @@ class MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscr
 {
 public:
     MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2901,22 +2333,14 @@ class MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -2926,16 +2350,9 @@ class MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscri
 {
 public:
     MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2950,20 +2367,12 @@ class MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge
 {
 public:
     MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -2974,16 +2383,9 @@ class MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionB
 {
 public:
     MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -2998,20 +2400,12 @@ class MTRLevelControlGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3021,16 +2415,9 @@ class MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3045,20 +2432,12 @@ class MTRLevelControlAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3068,16 +2447,9 @@ class MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3092,18 +2464,12 @@ class MTRLevelControlAttributeListListAttributeCallbackBridge
 {
 public:
     MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -3112,18 +2478,10 @@ class MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRLevelControlAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLevelControlAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3138,20 +2496,12 @@ class MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -3162,16 +2512,9 @@ class MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBr
 {
 public:
     MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3186,20 +2529,12 @@ class MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -3210,16 +2545,9 @@ class MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3234,20 +2562,12 @@ class MTRBinaryInputBasicAttributeListListAttributeCallbackBridge
 {
 public:
     MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -3256,18 +2576,10 @@ class MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRBinaryInputBasicAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3282,18 +2594,12 @@ class MTRDescriptorDeviceTypeListListAttributeCallbackBridge
 {
 public:
     MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -3305,18 +2611,10 @@ class MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge
     : public MTRDescriptorDeviceTypeListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3329,38 +2627,23 @@ class MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge
 class MTRDescriptorServerListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorServerListListAttributeCallback>
 {
 public:
-    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ClusterId> & value);
 };
 
 class MTRDescriptorServerListListAttributeCallbackSubscriptionBridge : public MTRDescriptorServerListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorServerListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorServerListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorServerListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3373,38 +2656,23 @@ class MTRDescriptorServerListListAttributeCallbackSubscriptionBridge : public MT
 class MTRDescriptorClientListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorClientListListAttributeCallback>
 {
 public:
-    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ClusterId> & value);
 };
 
 class MTRDescriptorClientListListAttributeCallbackSubscriptionBridge : public MTRDescriptorClientListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorClientListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorClientListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorClientListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3417,37 +2685,23 @@ class MTRDescriptorClientListListAttributeCallbackSubscriptionBridge : public MT
 class MTRDescriptorPartsListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorPartsListListAttributeCallback>
 {
 public:
-    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::EndpointId> & value);
 };
 
 class MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge : public MTRDescriptorPartsListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorPartsListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorPartsListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorPartsListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3462,20 +2716,12 @@ class MTRDescriptorGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3484,18 +2730,10 @@ class MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRDescriptorGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3510,20 +2748,12 @@ class MTRDescriptorAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3532,18 +2762,10 @@ class MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRDescriptorAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3556,19 +2778,12 @@ class MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRDescriptorAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>
 {
 public:
-    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -3577,18 +2792,10 @@ class MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRDescriptorAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDescriptorAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDescriptorAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3601,19 +2808,13 @@ class MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge
 class MTRBindingBindingListAttributeCallbackBridge : public MTRCallbackBridge<BindingBindingListAttributeCallback>
 {
 public:
-    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  bool keepAlive = false) :
         MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                               keepAlive){};
-
-    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType> & value);
@@ -3622,18 +2823,9 @@ class MTRBindingBindingListAttributeCallbackBridge : public MTRCallbackBridge<Bi
 class MTRBindingBindingListAttributeCallbackSubscriptionBridge : public MTRBindingBindingListAttributeCallbackBridge
 {
 public:
-    MTRBindingBindingListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action,
-                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingBindingListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBindingBindingListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRBindingBindingListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingBindingListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBindingBindingListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3648,20 +2840,12 @@ class MTRBindingGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3670,18 +2854,10 @@ class MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRBindingGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3696,20 +2872,12 @@ class MTRBindingAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3718,18 +2886,10 @@ class MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRBindingAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3742,38 +2902,23 @@ class MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRBindingAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<BindingAttributeListListAttributeCallback>
 {
 public:
-    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRBindingAttributeListListAttributeCallbackSubscriptionBridge : public MTRBindingAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBindingAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBindingAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3786,19 +2931,13 @@ class MTRBindingAttributeListListAttributeCallbackSubscriptionBridge : public MT
 class MTRAccessControlAclListAttributeCallbackBridge : public MTRCallbackBridge<AccessControlAclListAttributeCallback>
 {
 public:
-    MTRAccessControlAclListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRAccessControlAclListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlAclListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRAccessControlAclListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                    bool keepAlive = false) :
         MTRCallbackBridge<AccessControlAclListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlAclListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                   ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAclListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                 keepAlive){};
-
-    MTRAccessControlAclListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAclListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::AccessControlEntry::DecodableType> &
@@ -3808,18 +2947,10 @@ class MTRAccessControlAclListAttributeCallbackBridge : public MTRCallbackBridge<
 class MTRAccessControlAclListAttributeCallbackSubscriptionBridge : public MTRAccessControlAclListAttributeCallbackBridge
 {
 public:
-    MTRAccessControlAclListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlAclListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action,
                                                                MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlAclListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlAclListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlAclListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlAclListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3832,19 +2963,12 @@ class MTRAccessControlAclListAttributeCallbackSubscriptionBridge : public MTRAcc
 class MTRAccessControlExtensionListAttributeCallbackBridge : public MTRCallbackBridge<AccessControlExtensionListAttributeCallback>
 {
 public:
-    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -3855,18 +2979,10 @@ class MTRAccessControlExtensionListAttributeCallbackBridge : public MTRCallbackB
 class MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge : public MTRAccessControlExtensionListAttributeCallbackBridge
 {
 public:
-    MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlExtensionListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlExtensionListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlExtensionListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3881,20 +2997,12 @@ class MTRAccessControlGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3904,16 +3012,9 @@ class MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3928,20 +3029,12 @@ class MTRAccessControlAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -3951,16 +3044,9 @@ class MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -3975,20 +3061,12 @@ class MTRAccessControlAttributeListListAttributeCallbackBridge
 {
 public:
     MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -3997,18 +3075,10 @@ class MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRAccessControlAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4021,19 +3091,13 @@ class MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge
 class MTRActionsActionListListAttributeCallbackBridge : public MTRCallbackBridge<ActionsActionListListAttributeCallback>
 {
 public:
-    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                     bool keepAlive = false) :
         MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                  keepAlive){};
-
-    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType> & value);
@@ -4042,18 +3106,10 @@ class MTRActionsActionListListAttributeCallbackBridge : public MTRCallbackBridge
 class MTRActionsActionListListAttributeCallbackSubscriptionBridge : public MTRActionsActionListListAttributeCallbackBridge
 {
 public:
-    MTRActionsActionListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsActionListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsActionListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsActionListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsActionListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsActionListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4066,20 +3122,13 @@ class MTRActionsActionListListAttributeCallbackSubscriptionBridge : public MTRAc
 class MTRActionsEndpointListsListAttributeCallbackBridge : public MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>
 {
 public:
-    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType> &
@@ -4089,18 +3138,10 @@ class MTRActionsEndpointListsListAttributeCallbackBridge : public MTRCallbackBri
 class MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge : public MTRActionsEndpointListsListAttributeCallbackBridge
 {
 public:
-    MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsEndpointListsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsEndpointListsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsEndpointListsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4115,20 +3156,12 @@ class MTRActionsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4137,18 +3170,10 @@ class MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRActionsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4163,20 +3188,12 @@ class MTRActionsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4185,18 +3202,10 @@ class MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRActionsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4209,38 +3218,23 @@ class MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRActionsAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ActionsAttributeListListAttributeCallback>
 {
 public:
-    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRActionsAttributeListListAttributeCallbackSubscriptionBridge : public MTRActionsAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4253,19 +3247,12 @@ class MTRActionsAttributeListListAttributeCallbackSubscriptionBridge : public MT
 class MTRBasicCapabilityMinimaStructAttributeCallbackBridge : public MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>
 {
 public:
-    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::DecodableType & value);
@@ -4275,18 +3262,10 @@ class MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge
     : public MTRBasicCapabilityMinimaStructAttributeCallbackBridge
 {
 public:
-    MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4301,18 +3280,12 @@ class MTRBasicGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4321,18 +3294,10 @@ class MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRBasicGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4347,18 +3312,12 @@ class MTRBasicAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4367,18 +3326,10 @@ class MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRBasicAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4391,37 +3342,23 @@ class MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRBasicAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<BasicAttributeListListAttributeCallback>
 {
 public:
-    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                      bool keepAlive = false) :
         MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                   keepAlive){};
-
-    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRBasicAttributeListListAttributeCallbackSubscriptionBridge : public MTRBasicAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4436,23 +3373,14 @@ class MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridg
 {
 public:
     MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4462,17 +3390,9 @@ class MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubsc
 {
 public:
     MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4487,22 +3407,14 @@ class MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4512,17 +3424,9 @@ class MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscr
 {
 public:
     MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4537,20 +3441,12 @@ class MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge
 {
 public:
     MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateProviderAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -4561,16 +3457,9 @@ class MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscription
 {
 public:
     MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4585,23 +3474,14 @@ class MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridg
 {
 public:
     MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<
@@ -4613,17 +3493,9 @@ class MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubsc
 {
 public:
     MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4638,23 +3510,14 @@ class MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBrid
 {
 public:
     MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4664,17 +3527,9 @@ class MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubs
 {
 public:
     MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4689,23 +3544,14 @@ class MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridg
 {
 public:
     MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4715,17 +3561,9 @@ class MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubsc
 {
 public:
     MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4740,20 +3578,12 @@ class MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge
 {
 public:
     MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -4764,16 +3594,9 @@ class MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptio
 {
 public:
     MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4788,22 +3611,13 @@ class MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge
 {
 public:
     MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CharSpan> & value);
 };
@@ -4813,16 +3627,9 @@ class MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscript
 {
 public:
     MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4837,23 +3644,14 @@ class MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridg
 {
 public:
     MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4863,17 +3661,9 @@ class MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubsc
 {
 public:
     MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4888,22 +3678,14 @@ class MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -4913,17 +3695,9 @@ class MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscr
 {
 public:
     MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4938,20 +3712,12 @@ class MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge
 {
 public:
     MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -4962,16 +3728,9 @@ class MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscription
 {
 public:
     MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -4986,22 +3745,14 @@ class MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge
 {
 public:
     MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -5013,17 +3764,9 @@ class MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscr
 {
 public:
     MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5038,22 +3781,14 @@ class MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5063,16 +3798,9 @@ class MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscrip
 {
 public:
     MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5087,22 +3815,13 @@ class MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5112,16 +3831,9 @@ class MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscript
 {
 public:
     MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5136,20 +3848,12 @@ class MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge
 {
 public:
     MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -5160,16 +3864,9 @@ class MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5184,20 +3881,12 @@ class MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -5208,16 +3897,9 @@ class MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBr
 {
 public:
     MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5232,21 +3914,13 @@ class MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5256,16 +3930,9 @@ class MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5280,20 +3947,12 @@ class MTRUnitLocalizationAttributeListListAttributeCallbackBridge
 {
 public:
     MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -5302,18 +3961,10 @@ class MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRUnitLocalizationAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5328,20 +3979,12 @@ class MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
 };
@@ -5351,16 +3994,9 @@ class MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5375,22 +4011,14 @@ class MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5400,17 +4028,9 @@ class MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscr
 {
 public:
     MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5425,22 +4045,14 @@ class MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5450,16 +4062,9 @@ class MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscri
 {
 public:
     MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5474,20 +4079,12 @@ class MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -5498,16 +4095,9 @@ class MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionB
 {
 public:
     MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5522,20 +4112,12 @@ class MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFault> & value);
@@ -5545,18 +4127,10 @@ class MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5571,20 +4145,12 @@ class MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFault> & value);
@@ -5594,18 +4160,10 @@ class MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5620,20 +4178,12 @@ class MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFault> & value);
@@ -5644,16 +4194,9 @@ class MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5668,20 +4211,12 @@ class MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5691,16 +4226,9 @@ class MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5715,20 +4243,12 @@ class MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5737,18 +4257,10 @@ class MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5763,18 +4275,12 @@ class MTRPowerSourceAttributeListListAttributeCallbackBridge
 {
 public:
     MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -5783,18 +4289,10 @@ class MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5809,22 +4307,14 @@ class MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge
 {
 public:
     MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -5836,17 +4326,9 @@ class MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscr
 {
 public:
     MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5861,22 +4343,13 @@ class MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -5886,16 +4359,9 @@ class MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscripti
 {
 public:
     MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5910,20 +4376,12 @@ class MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -5934,16 +4392,9 @@ class MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptio
 {
 public:
     MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -5958,20 +4409,12 @@ class MTRGeneralCommissioningAttributeListListAttributeCallbackBridge
 {
 public:
     MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -5981,16 +4424,9 @@ class MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6005,20 +4441,12 @@ class MTRNetworkCommissioningNetworksListAttributeCallbackBridge
 {
 public:
     MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -6030,18 +4458,10 @@ class MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge
     : public MTRNetworkCommissioningNetworksListAttributeCallbackBridge
 {
 public:
-    MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6056,22 +4476,13 @@ class MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -6081,16 +4492,9 @@ class MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscripti
 {
 public:
     MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6105,20 +4509,12 @@ class MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -6129,16 +4525,9 @@ class MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptio
 {
 public:
     MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6153,20 +4542,12 @@ class MTRNetworkCommissioningAttributeListListAttributeCallbackBridge
 {
 public:
     MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -6176,16 +4557,9 @@ class MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6200,20 +4574,12 @@ class MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -6224,16 +4590,9 @@ class MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6248,20 +4607,12 @@ class MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -6271,16 +4622,9 @@ class MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6295,20 +4639,12 @@ class MTRDiagnosticLogsAttributeListListAttributeCallbackBridge
 {
 public:
     MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -6317,18 +4653,10 @@ class MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRDiagnosticLogsAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6343,20 +4671,12 @@ class MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -6369,16 +4689,9 @@ class MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBri
 {
 public:
     MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6393,20 +4706,12 @@ class MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
@@ -6417,16 +4722,9 @@ class MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscription
 {
 public:
     MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6441,20 +4739,12 @@ class MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
@@ -6465,16 +4755,9 @@ class MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBri
 {
 public:
     MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6489,20 +4772,12 @@ class MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
@@ -6513,16 +4788,9 @@ class MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionB
 {
 public:
     MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6537,20 +4805,12 @@ class MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -6561,16 +4821,9 @@ class MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscription
 {
 public:
     MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6585,20 +4838,12 @@ class MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -6609,16 +4854,9 @@ class MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionB
 {
 public:
     MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6633,20 +4871,12 @@ class MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -6656,16 +4886,9 @@ class MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6680,20 +4903,12 @@ class MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge
 {
 public:
     MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -6706,16 +4921,9 @@ class MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6730,20 +4938,12 @@ class MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -6754,16 +4954,9 @@ class MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptio
 {
 public:
     MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6778,20 +4971,12 @@ class MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -6802,16 +4987,9 @@ class MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscription
 {
 public:
     MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6826,20 +5004,12 @@ class MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge
 {
 public:
     MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -6849,16 +5019,9 @@ class MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6873,22 +5036,13 @@ class MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<
@@ -6900,16 +5054,9 @@ class MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscript
 {
 public:
     MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6924,20 +5071,12 @@ class MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -6950,16 +5089,9 @@ class MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscription
 {
 public:
     MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -6974,22 +5106,13 @@ class MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<
@@ -7001,16 +5124,9 @@ class MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscripti
 {
 public:
     MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7026,22 +5142,17 @@ class MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCall
 public:
     MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
-                                                                                         MTRLocalActionBlock action,
+                                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                       keepAlive){};
+
+    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                         ResponseHandler handler,
+                                                                                         MTRActionBlock action,
                                                                                          bool keepAlive = false) :
         MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void
     OnSuccessFn(void * context,
                 const chip::app::DataModel::Nullable<
@@ -7053,17 +5164,9 @@ class MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCall
 {
 public:
     MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                             action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7078,23 +5181,14 @@ class MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBri
 {
 public:
     MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -7106,17 +5200,9 @@ class MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSub
 {
 public:
     MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7131,22 +5217,14 @@ class MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7156,17 +5234,9 @@ class MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscr
 {
 public:
     MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7181,22 +5251,14 @@ class MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7206,16 +5268,9 @@ class MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscri
 {
 public:
     MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7230,20 +5285,12 @@ class MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -7254,16 +5301,9 @@ class MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionB
 {
 public:
     MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7278,22 +5318,14 @@ class MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7303,16 +5335,9 @@ class MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscrip
 {
 public:
     MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7327,22 +5352,13 @@ class MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7352,16 +5368,9 @@ class MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscript
 {
 public:
     MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7376,20 +5385,12 @@ class MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge
 {
 public:
     MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -7400,16 +5401,9 @@ class MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7424,23 +5418,14 @@ class MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBrid
 {
 public:
     MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7450,17 +5435,9 @@ class MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubs
 {
 public:
     MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7475,23 +5452,14 @@ class MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridg
 {
 public:
     MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7501,17 +5469,9 @@ class MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubsc
 {
 public:
     MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7526,20 +5486,12 @@ class MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge
 {
 public:
     MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -7550,16 +5502,9 @@ class MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptio
 {
 public:
     MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7574,22 +5519,14 @@ class MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                         MTRActionBlock action, bool keepAlive = false) :
         MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
-    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
 
@@ -7598,16 +5535,9 @@ class MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscription
 {
 public:
     MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7622,20 +5552,12 @@ class MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -7646,16 +5568,9 @@ class MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionB
 {
 public:
     MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7670,20 +5585,12 @@ class MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge
 {
 public:
     MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -7693,16 +5600,9 @@ class MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7717,20 +5617,12 @@ class MTRSwitchGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7739,18 +5631,10 @@ class MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRSwitchGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7765,18 +5649,12 @@ class MTRSwitchAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7785,18 +5663,10 @@ class MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRSwitchAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7809,37 +5679,23 @@ class MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRSwitchAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<SwitchAttributeListListAttributeCallback>
 {
 public:
-    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge : public MTRSwitchAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSwitchAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRSwitchAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRSwitchAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7854,23 +5710,14 @@ class MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBrid
 {
 public:
     MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7880,17 +5727,9 @@ class MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubs
 {
 public:
     MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7905,23 +5744,14 @@ class MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridg
 {
 public:
     MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -7931,17 +5761,9 @@ class MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubsc
 {
 public:
     MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -7956,20 +5778,12 @@ class MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge
 {
 public:
     MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -7980,16 +5794,9 @@ class MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptio
 {
 public:
     MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8004,20 +5811,12 @@ class MTROperationalCredentialsNOCsListAttributeCallbackBridge
 {
 public:
     MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -8029,18 +5828,10 @@ class MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge
     : public MTROperationalCredentialsNOCsListAttributeCallbackBridge
 {
 public:
-    MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8055,20 +5846,12 @@ class MTROperationalCredentialsFabricsListAttributeCallbackBridge
 {
 public:
     MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<
@@ -8079,18 +5862,10 @@ class MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge
     : public MTROperationalCredentialsFabricsListAttributeCallbackBridge
 {
 public:
-    MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8105,23 +5880,14 @@ class MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridg
 {
 public:
     MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & value);
 };
@@ -8131,17 +5897,9 @@ class MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubsc
 {
 public:
     MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8156,22 +5914,14 @@ class MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8181,16 +5931,9 @@ class MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscrip
 {
 public:
     MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8205,22 +5948,13 @@ class MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8230,16 +5964,9 @@ class MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscript
 {
 public:
     MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8254,20 +5981,12 @@ class MTROperationalCredentialsAttributeListListAttributeCallbackBridge
 {
 public:
     MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -8278,16 +5997,9 @@ class MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBri
 {
 public:
     MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8302,20 +6014,12 @@ class MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge
 {
 public:
     MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<
@@ -8326,18 +6030,10 @@ class MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge
     : public MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge
 {
 public:
-    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8352,20 +6048,12 @@ class MTRGroupKeyManagementGroupTableListAttributeCallbackBridge
 {
 public:
     MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<
@@ -8376,18 +6064,10 @@ class MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge
     : public MTRGroupKeyManagementGroupTableListAttributeCallbackBridge
 {
 public:
-    MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8402,20 +6082,12 @@ class MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -8426,16 +6098,9 @@ class MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscription
 {
 public:
     MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8450,20 +6115,12 @@ class MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -8474,16 +6131,9 @@ class MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionB
 {
 public:
     MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8498,20 +6148,12 @@ class MTRGroupKeyManagementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -8521,16 +6163,9 @@ class MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8543,19 +6178,13 @@ class MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge
 class MTRFixedLabelLabelListListAttributeCallbackBridge : public MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>
 {
 public:
-    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType> & value);
@@ -8564,18 +6193,10 @@ class MTRFixedLabelLabelListListAttributeCallbackBridge : public MTRCallbackBrid
 class MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge : public MTRFixedLabelLabelListListAttributeCallbackBridge
 {
 public:
-    MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelLabelListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelLabelListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFixedLabelLabelListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8590,20 +6211,12 @@ class MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8612,18 +6225,10 @@ class MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8638,20 +6243,12 @@ class MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8660,18 +6257,10 @@ class MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8684,19 +6273,12 @@ class MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRFixedLabelAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>
 {
 public:
-    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -8705,18 +6287,10 @@ class MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRFixedLabelAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8729,19 +6303,13 @@ class MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge
 class MTRUserLabelLabelListListAttributeCallbackBridge : public MTRCallbackBridge<UserLabelLabelListListAttributeCallback>
 {
 public:
-    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                      bool keepAlive = false) :
         MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                   keepAlive){};
-
-    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType> & value);
@@ -8750,18 +6318,10 @@ class MTRUserLabelLabelListListAttributeCallbackBridge : public MTRCallbackBridg
 class MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge : public MTRUserLabelLabelListListAttributeCallbackBridge
 {
 public:
-    MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelLabelListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelLabelListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUserLabelLabelListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8776,20 +6336,12 @@ class MTRUserLabelGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8798,18 +6350,10 @@ class MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRUserLabelGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8824,20 +6368,12 @@ class MTRUserLabelAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8846,18 +6382,10 @@ class MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRUserLabelAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8870,19 +6398,12 @@ class MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRUserLabelAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>
 {
 public:
-    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
-
-    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -8890,18 +6411,10 @@ class MTRUserLabelAttributeListListAttributeCallbackBridge : public MTRCallbackB
 class MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge : public MTRUserLabelAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUserLabelAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUserLabelAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8916,20 +6429,12 @@ class MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8939,16 +6444,9 @@ class MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -8963,20 +6461,12 @@ class MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -8986,16 +6476,9 @@ class MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9010,18 +6493,12 @@ class MTRBooleanStateAttributeListListAttributeCallbackBridge
 {
 public:
     MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -9030,18 +6507,10 @@ class MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRBooleanStateAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9056,18 +6525,12 @@ class MTRModeSelectSupportedModesListAttributeCallbackBridge
 {
 public:
     MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -9079,18 +6542,10 @@ class MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge
     : public MTRModeSelectSupportedModesListAttributeCallbackBridge
 {
 public:
-    MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9105,20 +6560,12 @@ class MTRModeSelectGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -9127,18 +6574,10 @@ class MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRModeSelectGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9153,20 +6592,12 @@ class MTRModeSelectAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -9175,18 +6606,10 @@ class MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRModeSelectAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9199,19 +6622,12 @@ class MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRModeSelectAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>
 {
 public:
-    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -9220,18 +6636,10 @@ class MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRModeSelectAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRModeSelectAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRModeSelectAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9246,20 +6654,12 @@ class MTRDoorLockCredentialRulesSupportAttributeCallbackBridge
 {
 public:
     MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> value);
 };
@@ -9268,18 +6668,10 @@ class MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge
     : public MTRDoorLockCredentialRulesSupportAttributeCallbackBridge
 {
 public:
-    MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9294,20 +6686,12 @@ class MTRDoorLockSupportedOperatingModesAttributeCallbackBridge
 {
 public:
     MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> value);
 };
@@ -9316,18 +6700,10 @@ class MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge
     : public MTRDoorLockSupportedOperatingModesAttributeCallbackBridge
 {
 public:
-    MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9342,20 +6718,12 @@ class MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge
 {
 public:
     MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> value);
 };
@@ -9365,16 +6733,9 @@ class MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge
 {
 public:
     MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9389,20 +6750,12 @@ class MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge
 {
 public:
     MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> value);
 };
@@ -9411,18 +6764,10 @@ class MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge
     : public MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge
 {
 public:
-    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9437,20 +6782,12 @@ class MTRDoorLockGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -9459,18 +6796,10 @@ class MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRDoorLockGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9485,20 +6814,12 @@ class MTRDoorLockAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -9507,18 +6828,10 @@ class MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRDoorLockAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9531,38 +6844,23 @@ class MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRDoorLockAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>
 {
 public:
-    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge : public MTRDoorLockAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9575,19 +6873,12 @@ class MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge : public M
 class MTRWindowCoveringConfigStatusAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>
 {
 public:
-    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> value);
 };
@@ -9595,18 +6886,10 @@ class MTRWindowCoveringConfigStatusAttributeCallbackBridge : public MTRCallbackB
 class MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge : public MTRWindowCoveringConfigStatusAttributeCallbackBridge
 {
 public:
-    MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9621,20 +6904,12 @@ class MTRWindowCoveringOperationalStatusAttributeCallbackBridge
 {
 public:
     MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> value);
 };
@@ -9643,18 +6918,10 @@ class MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge
     : public MTRWindowCoveringOperationalStatusAttributeCallbackBridge
 {
 public:
-    MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9667,37 +6934,22 @@ class MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge
 class MTRWindowCoveringModeAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringModeAttributeCallback>
 {
 public:
-    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  bool keepAlive = false) :
         MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                               keepAlive){};
-
-    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> value);
 };
 
 class MTRWindowCoveringModeAttributeCallbackSubscriptionBridge : public MTRWindowCoveringModeAttributeCallbackBridge
 {
 public:
-    MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action,
-                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9710,19 +6962,12 @@ class MTRWindowCoveringModeAttributeCallbackSubscriptionBridge : public MTRWindo
 class MTRWindowCoveringSafetyStatusAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>
 {
 public:
-    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> value);
 };
@@ -9730,18 +6975,10 @@ class MTRWindowCoveringSafetyStatusAttributeCallbackBridge : public MTRCallbackB
 class MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge : public MTRWindowCoveringSafetyStatusAttributeCallbackBridge
 {
 public:
-    MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9756,20 +6993,12 @@ class MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -9780,16 +7009,9 @@ class MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9804,20 +7026,12 @@ class MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -9827,16 +7041,9 @@ class MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9851,20 +7058,12 @@ class MTRWindowCoveringAttributeListListAttributeCallbackBridge
 {
 public:
     MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -9873,18 +7072,10 @@ class MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRWindowCoveringAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9899,20 +7090,12 @@ class MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -9923,16 +7106,9 @@ class MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9947,20 +7123,12 @@ class MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -9970,16 +7138,9 @@ class MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -9994,20 +7155,12 @@ class MTRBarrierControlAttributeListListAttributeCallbackBridge
 {
 public:
     MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -10016,18 +7169,10 @@ class MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRBarrierControlAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10042,20 +7187,12 @@ class MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge
 {
 public:
     MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatus> value);
 };
@@ -10065,16 +7202,9 @@ class MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridg
 {
 public:
     MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10089,23 +7219,14 @@ class MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBri
 {
 public:
     MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10115,17 +7236,9 @@ class MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSub
 {
 public:
     MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10140,24 +7253,15 @@ class MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBrid
 {
 public:
     MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                               keepAlive){};
+
+    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
         MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
 
@@ -10166,17 +7270,9 @@ class MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubs
 {
 public:
     MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10191,22 +7287,13 @@ class MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge
 {
 public:
     MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -10216,16 +7303,9 @@ class MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscripti
 {
 public:
     MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10240,20 +7320,12 @@ class MTRThermostatGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10262,18 +7334,10 @@ class MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRThermostatGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10288,20 +7352,12 @@ class MTRThermostatAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10310,18 +7366,10 @@ class MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRThermostatAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10334,19 +7382,12 @@ class MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRThermostatAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>
 {
 public:
-    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -10355,18 +7396,10 @@ class MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRThermostatAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10381,20 +7414,12 @@ class MTRFanControlGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10403,18 +7428,10 @@ class MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRFanControlGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10429,20 +7446,12 @@ class MTRFanControlAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10451,18 +7460,10 @@ class MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRFanControlAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10475,19 +7476,12 @@ class MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRFanControlAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<FanControlAttributeListListAttributeCallback>
 {
 public:
-    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -10496,18 +7490,10 @@ class MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRFanControlAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFanControlAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10523,21 +7509,16 @@ class MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCa
 public:
     MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                            ResponseHandler handler,
-                                                                                           MTRLocalActionBlock action,
                                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action,
+        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler,
                                                                                                          OnSuccessFn, keepAlive){};
 
-    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                           ResponseHandler handler,
+                                                                                           MTRActionBlock action,
+                                                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action,
+                                                                                                         OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10547,18 +7528,9 @@ class MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCa
 {
 public:
     MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                               action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action,
-                                                                                               true),
+        MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10574,22 +7546,17 @@ class MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCal
 public:
     MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
-                                                                                          MTRLocalActionBlock action,
+                                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                        keepAlive){};
+
+    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                          ResponseHandler handler,
+                                                                                          MTRActionBlock action,
                                                                                           bool keepAlive = false) :
         MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};
 
-    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
 
@@ -10598,17 +7565,9 @@ class MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCal
 {
 public:
     MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                              action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10623,22 +7582,13 @@ class MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackB
 {
 public:
     MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                    MTRLocalActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(queue, handler, action,
-                                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                    MTRDeviceController * controller,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                  keepAlive){};
 
-    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(queue, device, handler, action,
+    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                    MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -10649,17 +7599,9 @@ class MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackS
 {
 public:
     MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                        true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10674,20 +7616,12 @@ class MTRColorControlGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10697,16 +7631,9 @@ class MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10721,20 +7648,12 @@ class MTRColorControlAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10744,16 +7663,9 @@ class MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10768,18 +7680,12 @@ class MTRColorControlAttributeListListAttributeCallbackBridge
 {
 public:
     MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -10788,18 +7694,10 @@ class MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRColorControlAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10814,22 +7712,13 @@ class MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10839,16 +7728,9 @@ class MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscripti
 {
 public:
     MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10863,20 +7745,12 @@ class MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -10887,16 +7761,9 @@ class MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptio
 {
 public:
     MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10911,20 +7778,12 @@ class MTRBallastConfigurationAttributeListListAttributeCallbackBridge
 {
 public:
     MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -10934,16 +7793,9 @@ class MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -10958,22 +7810,14 @@ class MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -10983,16 +7827,9 @@ class MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscrip
 {
 public:
     MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11007,22 +7844,13 @@ class MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11032,16 +7860,9 @@ class MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscript
 {
 public:
     MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11056,20 +7877,12 @@ class MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -11080,16 +7893,9 @@ class MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11104,22 +7910,14 @@ class MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11129,16 +7927,9 @@ class MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscrip
 {
 public:
     MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11153,22 +7944,13 @@ class MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11178,16 +7960,9 @@ class MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscript
 {
 public:
     MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11202,20 +7977,12 @@ class MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -11226,16 +7993,9 @@ class MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11250,20 +8010,12 @@ class MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -11274,16 +8026,9 @@ class MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptio
 {
 public:
     MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11298,20 +8043,12 @@ class MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -11322,16 +8059,9 @@ class MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscription
 {
 public:
     MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11346,20 +8076,12 @@ class MTRPressureMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -11369,16 +8091,9 @@ class MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11393,20 +8108,12 @@ class MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -11417,16 +8124,9 @@ class MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11441,20 +8141,12 @@ class MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -11465,16 +8157,9 @@ class MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11489,20 +8174,12 @@ class MTRFlowMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -11511,18 +8188,10 @@ class MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRFlowMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11537,23 +8206,14 @@ class MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBri
 {
 public:
     MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11563,17 +8223,9 @@ class MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSub
 {
 public:
     MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11588,23 +8240,14 @@ class MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBrid
 {
 public:
     MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11614,17 +8257,9 @@ class MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubs
 {
 public:
     MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11639,22 +8274,13 @@ class MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -11664,16 +8290,9 @@ class MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscripti
 {
 public:
     MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11688,20 +8307,12 @@ class MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -11712,16 +8323,9 @@ class MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBr
 {
 public:
     MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11736,20 +8340,12 @@ class MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -11760,16 +8356,9 @@ class MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11784,20 +8373,12 @@ class MTROccupancySensingAttributeListListAttributeCallbackBridge
 {
 public:
     MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -11806,18 +8387,10 @@ class MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge
     : public MTROccupancySensingAttributeListListAttributeCallbackBridge
 {
 public:
-    MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11832,20 +8405,12 @@ class MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<WakeOnLanGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<WakeOnLanGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11854,18 +8419,10 @@ class MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11880,20 +8437,12 @@ class MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<WakeOnLanAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<WakeOnLanAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -11902,18 +8451,10 @@ class MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11926,19 +8467,12 @@ class MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRWakeOnLanAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<WakeOnLanAttributeListListAttributeCallback>
 {
 public:
-    MTRWakeOnLanAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRWakeOnLanAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRWakeOnLanAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<WakeOnLanAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWakeOnLanAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WakeOnLanAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRWakeOnLanAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<WakeOnLanAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -11946,18 +8480,10 @@ class MTRWakeOnLanAttributeListListAttributeCallbackBridge : public MTRCallbackB
 class MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge : public MTRWakeOnLanAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -11970,19 +8496,13 @@ class MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge : public
 class MTRChannelChannelListListAttributeCallbackBridge : public MTRCallbackBridge<ChannelChannelListListAttributeCallback>
 {
 public:
-    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                      bool keepAlive = false) :
         MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                   keepAlive){};
-
-    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::Channel::Structs::ChannelInfo::DecodableType> & value);
@@ -11991,18 +8511,10 @@ class MTRChannelChannelListListAttributeCallbackBridge : public MTRCallbackBridg
 class MTRChannelChannelListListAttributeCallbackSubscriptionBridge : public MTRChannelChannelListListAttributeCallbackBridge
 {
 public:
-    MTRChannelChannelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelChannelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelChannelListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelChannelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelChannelListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelChannelListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12015,19 +8527,13 @@ class MTRChannelChannelListListAttributeCallbackSubscriptionBridge : public MTRC
 class MTRChannelLineupStructAttributeCallbackBridge : public MTRCallbackBridge<ChannelLineupStructAttributeCallback>
 {
 public:
-    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                   bool keepAlive = false) :
         MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                keepAlive){};
-
-    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void
     OnSuccessFn(void * context,
                 const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfo::DecodableType> & value);
@@ -12036,18 +8542,10 @@ class MTRChannelLineupStructAttributeCallbackBridge : public MTRCallbackBridge<C
 class MTRChannelLineupStructAttributeCallbackSubscriptionBridge : public MTRChannelLineupStructAttributeCallbackBridge
 {
 public:
-    MTRChannelLineupStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelLineupStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelLineupStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelLineupStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelLineupStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelLineupStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12060,19 +8558,12 @@ class MTRChannelLineupStructAttributeCallbackSubscriptionBridge : public MTRChan
 class MTRChannelCurrentChannelStructAttributeCallbackBridge : public MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>
 {
 public:
-    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -12083,18 +8574,10 @@ class MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge
     : public MTRChannelCurrentChannelStructAttributeCallbackBridge
 {
 public:
-    MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12109,20 +8592,12 @@ class MTRChannelGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12131,18 +8606,10 @@ class MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRChannelGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12157,20 +8624,12 @@ class MTRChannelAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12179,18 +8638,10 @@ class MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRChannelAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12203,38 +8654,23 @@ class MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRChannelAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ChannelAttributeListListAttributeCallback>
 {
 public:
-    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRChannelAttributeListListAttributeCallbackSubscriptionBridge : public MTRChannelAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12249,18 +8685,12 @@ class MTRTargetNavigatorTargetListListAttributeCallbackBridge
 {
 public:
     MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -12272,18 +8702,10 @@ class MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge
     : public MTRTargetNavigatorTargetListListAttributeCallbackBridge
 {
 public:
-    MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12298,20 +8720,12 @@ class MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -12322,16 +8736,9 @@ class MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12346,20 +8753,12 @@ class MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -12370,16 +8769,9 @@ class MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12394,20 +8786,12 @@ class MTRTargetNavigatorAttributeListListAttributeCallbackBridge
 {
 public:
     MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -12416,18 +8800,10 @@ class MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRTargetNavigatorAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12442,20 +8818,12 @@ class MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge
 {
 public:
     MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -12466,18 +8834,10 @@ class MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge
     : public MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge
 {
 public:
-    MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12492,20 +8852,12 @@ class MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12515,16 +8867,9 @@ class MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12539,20 +8884,12 @@ class MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12562,16 +8899,9 @@ class MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12586,20 +8916,12 @@ class MTRMediaPlaybackAttributeListListAttributeCallbackBridge
 {
 public:
     MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -12608,18 +8930,10 @@ class MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRMediaPlaybackAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12632,19 +8946,13 @@ class MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge
 class MTRMediaInputInputListListAttributeCallbackBridge : public MTRCallbackBridge<MediaInputInputListListAttributeCallback>
 {
 public:
-    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::MediaInput::Structs::InputInfo::DecodableType> & value);
@@ -12653,18 +8961,10 @@ class MTRMediaInputInputListListAttributeCallbackBridge : public MTRCallbackBrid
 class MTRMediaInputInputListListAttributeCallbackSubscriptionBridge : public MTRMediaInputInputListListAttributeCallbackBridge
 {
 public:
-    MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputInputListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputInputListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaInputInputListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12679,20 +8979,12 @@ class MTRMediaInputGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12701,18 +8993,10 @@ class MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRMediaInputGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12727,20 +9011,12 @@ class MTRMediaInputAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12749,18 +9025,10 @@ class MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRMediaInputAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12773,19 +9041,12 @@ class MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRMediaInputAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>
 {
 public:
-    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -12794,18 +9055,10 @@ class MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRMediaInputAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaInputAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12820,20 +9073,12 @@ class MTRLowPowerGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12842,18 +9087,10 @@ class MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRLowPowerGeneratedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12868,20 +9105,12 @@ class MTRLowPowerAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12890,18 +9119,10 @@ class MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRLowPowerAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12914,38 +9135,23 @@ class MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge
 class MTRLowPowerAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>
 {
 public:
-    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
 
 class MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge : public MTRLowPowerAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLowPowerAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLowPowerAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLowPowerAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -12960,20 +9166,12 @@ class MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -12983,16 +9181,9 @@ class MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13007,20 +9198,12 @@ class MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -13029,18 +9212,10 @@ class MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13055,18 +9230,12 @@ class MTRKeypadInputAttributeListListAttributeCallbackBridge
 {
 public:
     MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -13075,18 +9244,10 @@ class MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRKeypadInputAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13101,20 +9262,12 @@ class MTRContentLauncherAcceptHeaderListAttributeCallbackBridge
 {
 public:
     MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CharSpan> & value);
 };
@@ -13123,18 +9276,10 @@ class MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge
     : public MTRContentLauncherAcceptHeaderListAttributeCallbackBridge
 {
 public:
-    MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13149,20 +9294,12 @@ class MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -13173,16 +9310,9 @@ class MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13197,20 +9327,12 @@ class MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -13221,16 +9343,9 @@ class MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13245,20 +9360,12 @@ class MTRContentLauncherAttributeListListAttributeCallbackBridge
 {
 public:
     MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -13267,18 +9374,10 @@ class MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRContentLauncherAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13291,20 +9390,13 @@ class MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge
 class MTRAudioOutputOutputListListAttributeCallbackBridge : public MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>
 {
 public:
-    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(
         void * context,
         const chip::app::DataModel::DecodableList<chip::app::Clusters::AudioOutput::Structs::OutputInfo::DecodableType> & value);
@@ -13313,18 +9405,10 @@ class MTRAudioOutputOutputListListAttributeCallbackBridge : public MTRCallbackBr
 class MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge : public MTRAudioOutputOutputListListAttributeCallbackBridge
 {
 public:
-    MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputOutputListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputOutputListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAudioOutputOutputListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13339,20 +9423,12 @@ class MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -13362,16 +9438,9 @@ class MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13386,20 +9455,12 @@ class MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -13408,18 +9469,10 @@ class MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13434,18 +9487,12 @@ class MTRAudioOutputAttributeListListAttributeCallbackBridge
 {
 public:
     MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -13454,18 +9501,10 @@ class MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRAudioOutputAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13480,20 +9519,12 @@ class MTRApplicationLauncherCatalogListListAttributeCallbackBridge
 {
 public:
     MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint16_t> & value);
 };
@@ -13502,18 +9533,10 @@ class MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge
     : public MTRApplicationLauncherCatalogListListAttributeCallbackBridge
 {
 public:
-    MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13528,20 +9551,12 @@ class MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge
 {
 public:
     MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -13554,16 +9569,9 @@ class MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge
 {
 public:
     MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13578,20 +9586,12 @@ class MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -13602,16 +9602,9 @@ class MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptio
 {
 public:
     MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13626,20 +9619,12 @@ class MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -13650,16 +9635,9 @@ class MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscription
 {
 public:
     MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13674,20 +9652,12 @@ class MTRApplicationLauncherAttributeListListAttributeCallbackBridge
 {
 public:
     MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -13697,16 +9667,9 @@ class MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13721,20 +9684,12 @@ class MTRApplicationBasicApplicationStructAttributeCallbackBridge
 {
 public:
     MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -13745,18 +9700,10 @@ class MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge
     : public MTRApplicationBasicApplicationStructAttributeCallbackBridge
 {
 public:
-    MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13771,20 +9718,12 @@ class MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge
 {
 public:
     MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::VendorId> & value);
 };
@@ -13794,16 +9733,9 @@ class MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridg
 {
 public:
     MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13818,20 +9750,12 @@ class MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -13842,16 +9766,9 @@ class MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBr
 {
 public:
     MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13866,20 +9783,12 @@ class MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
@@ -13890,16 +9799,9 @@ class MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBri
 {
 public:
     MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13914,20 +9816,12 @@ class MTRApplicationBasicAttributeListListAttributeCallbackBridge
 {
 public:
     MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -13936,18 +9830,10 @@ class MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRApplicationBasicAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -13962,20 +9848,12 @@ class MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -13985,16 +9863,9 @@ class MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14009,20 +9880,12 @@ class MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -14032,16 +9895,9 @@ class MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14056,18 +9912,12 @@ class MTRAccountLoginAttributeListListAttributeCallbackBridge
 {
 public:
     MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -14076,18 +9926,10 @@ class MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRAccountLoginAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14102,22 +9944,13 @@ class MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -14127,16 +9960,9 @@ class MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscript
 {
 public:
     MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14151,22 +9977,13 @@ class MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -14176,16 +9993,9 @@ class MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscripti
 {
 public:
     MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14200,20 +10010,12 @@ class MTRElectricalMeasurementAttributeListListAttributeCallbackBridge
 {
 public:
     MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
@@ -14224,16 +10026,9 @@ class MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBrid
 {
 public:
     MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14246,37 +10041,22 @@ class MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBrid
 class MTRTestClusterBitmap8AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap8AttributeCallback>
 {
 public:
-    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                  bool keepAlive = false) :
         MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                               keepAlive){};
-
-    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap8MaskMap> value);
 };
 
 class MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap8AttributeCallbackBridge
 {
 public:
-    MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action,
-                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap8AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap8AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterBitmap8AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14289,37 +10069,23 @@ class MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge : public MTRTestC
 class MTRTestClusterBitmap16AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap16AttributeCallback>
 {
 public:
-    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                   bool keepAlive = false) :
         MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                keepAlive){};
-
-    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap16MaskMap> value);
 };
 
 class MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap16AttributeCallbackBridge
 {
 public:
-    MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap16AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap16AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterBitmap16AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14332,37 +10098,23 @@ class MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge : public MTRTest
 class MTRTestClusterBitmap32AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap32AttributeCallback>
 {
 public:
-    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                   bool keepAlive = false) :
         MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                keepAlive){};
-
-    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap32MaskMap> value);
 };
 
 class MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap32AttributeCallbackBridge
 {
 public:
-    MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap32AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap32AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterBitmap32AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14375,37 +10127,23 @@ class MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge : public MTRTest
 class MTRTestClusterBitmap64AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap64AttributeCallback>
 {
 public:
-    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                   bool keepAlive = false) :
         MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                keepAlive){};
-
-    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap64MaskMap> value);
 };
 
 class MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap64AttributeCallbackBridge
 {
 public:
-    MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap64AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterBitmap64AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterBitmap64AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14418,38 +10156,23 @@ class MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge : public MTRTest
 class MTRTestClusterListInt8uListAttributeCallbackBridge : public MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>
 {
 public:
-    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
 };
 
 class MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge : public MTRTestClusterListInt8uListAttributeCallbackBridge
 {
 public:
-    MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListInt8uListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListInt8uListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterListInt8uListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14464,20 +10187,12 @@ class MTRTestClusterListOctetStringListAttributeCallbackBridge
 {
 public:
     MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & value);
 };
@@ -14486,18 +10201,10 @@ class MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge
     : public MTRTestClusterListOctetStringListAttributeCallbackBridge
 {
 public:
-    MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14512,20 +10219,12 @@ class MTRTestClusterListStructOctetStringListAttributeCallbackBridge
 {
 public:
     MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -14538,16 +10237,9 @@ class MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14562,22 +10254,14 @@ class MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge
 {
 public:
     MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::DecodableList<
@@ -14589,16 +10273,9 @@ class MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscrip
 {
 public:
     MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14611,19 +10288,12 @@ class MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscrip
 class MTRTestClusterStructAttrStructAttributeCallbackBridge : public MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>
 {
 public:
-    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & value);
 };
@@ -14632,18 +10302,10 @@ class MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge
     : public MTRTestClusterStructAttrStructAttributeCallbackBridge
 {
 public:
-    MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14658,20 +10320,12 @@ class MTRTestClusterListLongOctetStringListAttributeCallbackBridge
 {
 public:
     MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & value);
 };
@@ -14680,18 +10334,10 @@ class MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge
     : public MTRTestClusterListLongOctetStringListAttributeCallbackBridge
 {
 public:
-    MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14706,20 +10352,12 @@ class MTRTestClusterListFabricScopedListAttributeCallbackBridge
 {
 public:
     MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -14731,18 +10369,10 @@ class MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge
     : public MTRTestClusterListFabricScopedListAttributeCallbackBridge
 {
 public:
-    MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14755,19 +10385,12 @@ class MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge
 class MTRTestClusterNullableBitmap8AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>
 {
 public:
-    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -14777,18 +10400,10 @@ class MTRTestClusterNullableBitmap8AttributeCallbackBridge : public MTRCallbackB
 class MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge : public MTRTestClusterNullableBitmap8AttributeCallbackBridge
 {
 public:
-    MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14801,19 +10416,12 @@ class MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge : public
 class MTRTestClusterNullableBitmap16AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>
 {
 public:
-    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -14824,18 +10432,10 @@ class MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge
     : public MTRTestClusterNullableBitmap16AttributeCallbackBridge
 {
 public:
-    MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14848,19 +10448,12 @@ class MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge
 class MTRTestClusterNullableBitmap32AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>
 {
 public:
-    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -14871,18 +10464,10 @@ class MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge
     : public MTRTestClusterNullableBitmap32AttributeCallbackBridge
 {
 public:
-    MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14895,19 +10480,12 @@ class MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge
 class MTRTestClusterNullableBitmap64AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>
 {
 public:
-    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -14918,18 +10496,10 @@ class MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge
     : public MTRTestClusterNullableBitmap64AttributeCallbackBridge
 {
 public:
-    MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14944,20 +10514,12 @@ class MTRTestClusterNullableStructStructAttributeCallbackBridge
 {
 public:
     MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -14968,18 +10530,10 @@ class MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge
     : public MTRTestClusterNullableStructStructAttributeCallbackBridge
 {
 public:
-    MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -14994,20 +10548,12 @@ class MTRTestClusterGeneratedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -15017,16 +10563,9 @@ class MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge
 {
 public:
     MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -15041,20 +10580,12 @@ class MTRTestClusterAcceptedCommandListListAttributeCallbackBridge
 {
 public:
     MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
 };
@@ -15063,18 +10594,10 @@ class MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge
     : public MTRTestClusterAcceptedCommandListListAttributeCallbackBridge
 {
 public:
-    MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -15089,18 +10612,12 @@ class MTRTestClusterAttributeListListAttributeCallbackBridge
 {
 public:
     MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
 };
@@ -15109,18 +10626,10 @@ class MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge
     : public MTRTestClusterAttributeListListAttributeCallbackBridge
 {
 public:
-    MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterAttributeListListAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -15133,38 +10642,26 @@ class MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge
 class MTRGroupsClusterAddGroupResponseCallbackBridge : public MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>
 {
 public:
-    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                    bool keepAlive = false) :
         MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                   ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Groups::Commands::AddGroupResponse::DecodableType & data);
 };
 
 class MTRGroupsClusterViewGroupResponseCallbackBridge : public MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>
 {
 public:
-    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                     bool keepAlive = false) :
         MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Groups::Commands::ViewGroupResponse::DecodableType & data);
 };
 
@@ -15173,20 +10670,12 @@ class MTRGroupsClusterGetGroupMembershipResponseCallbackBridge
 {
 public:
     MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Groups::Commands::GetGroupMembershipResponse::DecodableType & data);
@@ -15195,76 +10684,52 @@ class MTRGroupsClusterGetGroupMembershipResponseCallbackBridge
 class MTRGroupsClusterRemoveGroupResponseCallbackBridge : public MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>
 {
 public:
-    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Groups::Commands::RemoveGroupResponse::DecodableType & data);
 };
 
 class MTRScenesClusterAddSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>
 {
 public:
-    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                    bool keepAlive = false) :
         MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                   ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                     keepAlive){};
-
-    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::AddSceneResponse::DecodableType & data);
 };
 
 class MTRScenesClusterViewSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>
 {
 public:
-    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                     bool keepAlive = false) :
         MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::ViewSceneResponse::DecodableType & data);
 };
 
 class MTRScenesClusterRemoveSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>
 {
 public:
-    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::RemoveSceneResponse::DecodableType & data);
 };
 
@@ -15272,20 +10737,12 @@ class MTRScenesClusterRemoveAllScenesResponseCallbackBridge
     : public MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>
 {
 public:
-    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Scenes::Commands::RemoveAllScenesResponse::DecodableType & data);
@@ -15294,19 +10751,13 @@ class MTRScenesClusterRemoveAllScenesResponseCallbackBridge
 class MTRScenesClusterStoreSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>
 {
 public:
-    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                      bool keepAlive = false) :
         MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
-
-    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::StoreSceneResponse::DecodableType & data);
 };
 
@@ -15315,20 +10766,12 @@ class MTRScenesClusterGetSceneMembershipResponseCallbackBridge
 {
 public:
     MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Scenes::Commands::GetSceneMembershipResponse::DecodableType & data);
@@ -15339,19 +10782,12 @@ class MTRScenesClusterEnhancedAddSceneResponseCallbackBridge
 {
 public:
     MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+    MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Scenes::Commands::EnhancedAddSceneResponse::DecodableType & data);
@@ -15362,19 +10798,12 @@ class MTRScenesClusterEnhancedViewSceneResponseCallbackBridge
 {
 public:
     MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+    MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Scenes::Commands::EnhancedViewSceneResponse::DecodableType & data);
@@ -15383,19 +10812,13 @@ class MTRScenesClusterEnhancedViewSceneResponseCallbackBridge
 class MTRScenesClusterCopySceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>
 {
 public:
-    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                     bool keepAlive = false) :
         MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::CopySceneResponse::DecodableType & data);
 };
 
@@ -15404,21 +10827,13 @@ class MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge
 {
 public:
     MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15430,21 +10845,14 @@ class MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge
 {
 public:
     MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, handler, OnSuccessFn,
                                                                                            keepAlive){};
 
-    MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15456,20 +10864,12 @@ class MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge
 {
 public:
     MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -15481,22 +10881,14 @@ class MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge
 {
 public:
     MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                              keepAlive){};
-
-    MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, handler, OnSuccessFn,
+                                                                                              keepAlive){};
 
-    MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15508,22 +10900,14 @@ class MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge
 {
 public:
     MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                                keepAlive){};
-
-    MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, handler, OnSuccessFn,
+                                                                                                keepAlive){};
 
-    MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15535,20 +10919,12 @@ class MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge
 {
 public:
     MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -15560,20 +10936,12 @@ class MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge
 {
 public:
     MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -15585,21 +10953,13 @@ class MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge
 {
 public:
     MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15611,20 +10971,12 @@ class MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge
 {
 public:
     MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data);
@@ -15635,20 +10987,12 @@ class MTROperationalCredentialsClusterAttestationResponseCallbackBridge
 {
 public:
     MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -15660,22 +11004,14 @@ class MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge
 {
 public:
     MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15687,20 +11023,12 @@ class MTROperationalCredentialsClusterCSRResponseCallbackBridge
 {
 public:
     MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::OperationalCredentials::Commands::CSRResponse::DecodableType & data);
@@ -15711,20 +11039,12 @@ class MTROperationalCredentialsClusterNOCResponseCallbackBridge
 {
 public:
     MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType & data);
@@ -15735,20 +11055,12 @@ class MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge
 {
 public:
     MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -15760,22 +11072,14 @@ class MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge
 {
 public:
     MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -15787,20 +11091,12 @@ class MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge
 {
 public:
     MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::DoorLock::Commands::GetWeekDayScheduleResponse::DecodableType & data);
@@ -15811,20 +11107,12 @@ class MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge
 {
 public:
     MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::DoorLock::Commands::GetYearDayScheduleResponse::DecodableType & data);
@@ -15835,20 +11123,12 @@ class MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge
 {
 public:
     MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::DoorLock::Commands::GetHolidayScheduleResponse::DecodableType & data);
@@ -15857,19 +11137,13 @@ class MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge
 class MTRDoorLockClusterGetUserResponseCallbackBridge : public MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>
 {
 public:
-    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                     bool keepAlive = false) :
         MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, const chip::app::Clusters::DoorLock::Commands::GetUserResponse::DecodableType & data);
 };
 
@@ -15877,20 +11151,12 @@ class MTRDoorLockClusterSetCredentialResponseCallbackBridge
     : public MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>
 {
 public:
-    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::DoorLock::Commands::SetCredentialResponse::DecodableType & data);
@@ -15901,20 +11167,12 @@ class MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge
 {
 public:
     MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::DoorLock::Commands::GetCredentialStatusResponse::DecodableType & data);
@@ -15925,20 +11183,12 @@ class MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge
 {
 public:
     MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Thermostat::Commands::GetWeeklyScheduleResponse::DecodableType & data);
@@ -15948,20 +11198,12 @@ class MTRChannelClusterChangeChannelResponseCallbackBridge
     : public MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>
 {
 public:
-    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
-
-    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::Channel::Commands::ChangeChannelResponse::DecodableType & data);
@@ -15972,20 +11214,12 @@ class MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge
 {
 public:
     MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -15996,20 +11230,12 @@ class MTRMediaPlaybackClusterPlaybackResponseCallbackBridge
     : public MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>
 {
 public:
-    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType & data);
@@ -16018,20 +11244,13 @@ class MTRMediaPlaybackClusterPlaybackResponseCallbackBridge
 class MTRKeypadInputClusterSendKeyResponseCallbackBridge : public MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>
 {
 public:
-    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::KeypadInput::Commands::SendKeyResponse::DecodableType & data);
 };
@@ -16040,20 +11259,12 @@ class MTRContentLauncherClusterLaunchResponseCallbackBridge
     : public MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>
 {
 public:
-    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::ContentLauncher::Commands::LaunchResponse::DecodableType & data);
@@ -16064,20 +11275,12 @@ class MTRApplicationLauncherClusterLauncherResponseCallbackBridge
 {
 public:
     MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType & data);
@@ -16088,19 +11291,12 @@ class MTRAccountLoginClusterGetSetupPINResponseCallbackBridge
 {
 public:
     MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+    MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::AccountLogin::Commands::GetSetupPINResponse::DecodableType & data);
@@ -16111,19 +11307,12 @@ class MTRTestClusterClusterTestSpecificResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+    MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::TestCluster::Commands::TestSpecificResponse::DecodableType & data);
@@ -16134,20 +11323,12 @@ class MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType & data);
@@ -16158,20 +11339,12 @@ class MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -16183,21 +11356,13 @@ class MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -16209,20 +11374,12 @@ class MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -16233,20 +11390,12 @@ class MTRTestClusterClusterTestEnumsResponseCallbackBridge
     : public MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>
 {
 public:
-    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::TestCluster::Commands::TestEnumsResponse::DecodableType & data);
@@ -16257,20 +11406,12 @@ class MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -16282,22 +11423,14 @@ class MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -16307,20 +11440,13 @@ class MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge
 class MTRTestClusterClusterBooleanResponseCallbackBridge : public MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>
 {
 public:
-    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                        bool keepAlive = false) :
         MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                       MTRDeviceController * controller, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType & data);
 };
@@ -16330,19 +11456,12 @@ class MTRTestClusterClusterSimpleStructResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+    MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & data);
@@ -16353,20 +11472,12 @@ class MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -16378,22 +11489,14 @@ class MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge
 {
 public:
     MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, handler, action, OnSuccessFn,
-                                                                                               keepAlive){};
-
-    MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, handler, OnSuccessFn,
+                                                                                               keepAlive){};
 
-    MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -16405,20 +11508,12 @@ class MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge
 {
 public:
     MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyEffectIdentifier value);
@@ -16429,16 +11524,9 @@ class MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBri
 {
 public:
     MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16453,22 +11541,14 @@ class MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge
 {
 public:
     MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyEffectIdentifier> & value);
@@ -16479,16 +11559,9 @@ class MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscri
 {
 public:
     MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16503,20 +11576,12 @@ class MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge
 {
 public:
     MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyEffectVariant value);
 };
@@ -16526,16 +11591,9 @@ class MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge
 {
 public:
     MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16550,22 +11608,13 @@ class MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge
 {
 public:
     MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyEffectVariant> & value);
@@ -16576,16 +11625,9 @@ class MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscripti
 {
 public:
     MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16600,20 +11642,12 @@ class MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge
 {
 public:
     MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyIdentifyType value);
 };
@@ -16623,16 +11657,9 @@ class MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16647,20 +11674,12 @@ class MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge
 {
 public:
     MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -16672,16 +11691,9 @@ class MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptio
 {
 public:
     MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16696,20 +11708,12 @@ class MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge
 {
 public:
     MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant value);
@@ -16720,16 +11724,9 @@ class MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptio
 {
 public:
     MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16744,23 +11741,14 @@ class MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBri
 {
 public:
     MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -16772,17 +11760,9 @@ class MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSub
 {
 public:
     MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16797,20 +11777,12 @@ class MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge
 {
 public:
     MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant value);
@@ -16821,16 +11793,9 @@ class MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBr
 {
 public:
     MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16845,22 +11810,14 @@ class MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge
 {
 public:
     MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant> & value);
@@ -16871,17 +11828,9 @@ class MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscr
 {
 public:
     MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16896,20 +11845,12 @@ class MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
 {
 public:
     MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffEffectIdentifier value);
 };
@@ -16918,18 +11859,10 @@ class MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge
     : public MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
 {
 public:
-    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16944,20 +11877,12 @@ class MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
 {
 public:
     MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -16969,16 +11894,9 @@ class MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionB
 {
 public:
     MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -16993,18 +11911,12 @@ class MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
 {
 public:
     MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffStartUpOnOff value);
 };
@@ -17013,18 +11925,10 @@ class MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge
     : public MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
 {
 public:
-    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17039,20 +11943,12 @@ class MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
 {
 public:
     MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffStartUpOnOff> & value);
@@ -17063,16 +11959,9 @@ class MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridg
 {
 public:
     MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17085,19 +11974,12 @@ class MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridg
 class MTRLevelControlClusterMoveModeAttributeCallbackBridge : public MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>
 {
 public:
-    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
-
-    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::LevelControl::MoveMode value);
 };
@@ -17106,18 +11988,10 @@ class MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge
     : public MTRLevelControlClusterMoveModeAttributeCallbackBridge
 {
 public:
-    MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlClusterMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlClusterMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLevelControlClusterMoveModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17132,20 +12006,12 @@ class MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge
 {
 public:
     MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::LevelControl::MoveMode> & value);
@@ -17156,16 +12022,9 @@ class MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17178,19 +12037,12 @@ class MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge
 class MTRLevelControlClusterStepModeAttributeCallbackBridge : public MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>
 {
 public:
-    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::LevelControl::StepMode value);
 };
@@ -17199,18 +12051,10 @@ class MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge
     : public MTRLevelControlClusterStepModeAttributeCallbackBridge
 {
 public:
-    MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlClusterStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRLevelControlClusterStepModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRLevelControlClusterStepModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17225,20 +12069,12 @@ class MTRNullableLevelControlClusterStepModeAttributeCallbackBridge
 {
 public:
     MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::LevelControl::StepMode> & value);
@@ -17249,16 +12085,9 @@ class MTRNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17273,18 +12102,12 @@ class MTRAccessControlClusterAuthModeAttributeCallbackBridge
 {
 public:
     MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::AuthMode value);
 };
@@ -17293,18 +12116,10 @@ class MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge
     : public MTRAccessControlClusterAuthModeAttributeCallbackBridge
 {
 public:
-    MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlClusterAuthModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlClusterAuthModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlClusterAuthModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17319,20 +12134,12 @@ class MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge
 {
 public:
     MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::AuthMode> & value);
@@ -17343,16 +12150,9 @@ class MTRNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17367,20 +12167,12 @@ class MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge
 {
 public:
     MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::ChangeTypeEnum value);
 };
@@ -17389,18 +12181,10 @@ class MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge
     : public MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge
 {
 public:
-    MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17415,20 +12199,12 @@ class MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -17440,16 +12216,9 @@ class MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackSubscription
 {
 public:
     MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17464,18 +12233,12 @@ class MTRAccessControlClusterPrivilegeAttributeCallbackBridge
 {
 public:
     MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::Privilege value);
 };
@@ -17484,18 +12247,10 @@ class MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge
     : public MTRAccessControlClusterPrivilegeAttributeCallbackBridge
 {
 public:
-    MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlClusterPrivilegeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAccessControlClusterPrivilegeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAccessControlClusterPrivilegeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17510,20 +12265,12 @@ class MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge
 {
 public:
     MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::Privilege> & value);
@@ -17534,16 +12281,9 @@ class MTRNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridg
 {
 public:
     MTRNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17558,18 +12298,12 @@ class MTRActionsClusterActionErrorEnumAttributeCallbackBridge
 {
 public:
     MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Actions::ActionErrorEnum value);
 };
@@ -17578,18 +12312,10 @@ class MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge
     : public MTRActionsClusterActionErrorEnumAttributeCallbackBridge
 {
 public:
-    MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterActionErrorEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterActionErrorEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsClusterActionErrorEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17604,20 +12330,12 @@ class MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge
 {
 public:
     MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionErrorEnum> & value);
@@ -17628,16 +12346,9 @@ class MTRNullableActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridg
 {
 public:
     MTRNullableActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17652,18 +12363,12 @@ class MTRActionsClusterActionStateEnumAttributeCallbackBridge
 {
 public:
     MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
-
-    MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Actions::ActionStateEnum value);
 };
@@ -17672,18 +12377,10 @@ class MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge
     : public MTRActionsClusterActionStateEnumAttributeCallbackBridge
 {
 public:
-    MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterActionStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterActionStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsClusterActionStateEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17698,20 +12395,12 @@ class MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge
 {
 public:
     MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionStateEnum> & value);
@@ -17722,16 +12411,9 @@ class MTRNullableActionsClusterActionStateEnumAttributeCallbackSubscriptionBridg
 {
 public:
     MTRNullableActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17746,18 +12428,12 @@ class MTRActionsClusterActionTypeEnumAttributeCallbackBridge
 {
 public:
     MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Actions::ActionTypeEnum value);
 };
@@ -17766,18 +12442,10 @@ class MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge
     : public MTRActionsClusterActionTypeEnumAttributeCallbackBridge
 {
 public:
-    MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterActionTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterActionTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsClusterActionTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17792,20 +12460,12 @@ class MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionTypeEnum> & value);
@@ -17816,16 +12476,9 @@ class MTRNullableActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17840,20 +12493,12 @@ class MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge
 {
 public:
     MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Actions::EndpointListTypeEnum value);
 };
@@ -17862,18 +12507,10 @@ class MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge
     : public MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge
 {
 public:
-    MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17888,20 +12525,12 @@ class MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -17913,16 +12542,9 @@ class MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackSubscription
 {
 public:
     MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17937,22 +12559,13 @@ class MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBr
 {
 public:
     MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, device, handler, action,
+    MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction value);
@@ -17963,17 +12576,9 @@ class MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSu
 {
 public:
     MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -17989,21 +12594,16 @@ class MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCa
 public:
     MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                            ResponseHandler handler,
-                                                                                           MTRLocalActionBlock action,
                                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, action,
+        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler,
                                                                                                          OnSuccessFn, keepAlive){};
 
-    MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                           ResponseHandler handler,
+                                                                                           MTRActionBlock action,
+                                                                                           bool keepAlive = false) :
+        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, action,
+                                                                                                         OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -18015,18 +12615,9 @@ class MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCa
 {
 public:
     MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                               action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, device, handler, action,
-                                                                                               true),
+        MTRNullableOtaSoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18041,23 +12632,14 @@ class MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBri
 {
 public:
     MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol value);
 };
@@ -18067,17 +12649,9 @@ class MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSub
 {
 public:
     MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18093,22 +12667,17 @@ class MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCal
 public:
     MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
-                                                                                          MTRLocalActionBlock action,
+                                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                        keepAlive){};
+
+    MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                          ResponseHandler handler,
+                                                                                          MTRActionBlock action,
                                                                                           bool keepAlive = false) :
         MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};
 
-    MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void
     OnSuccessFn(void * context,
                 const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol> & value);
@@ -18119,17 +12688,9 @@ class MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCal
 {
 public:
     MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                              action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOtaSoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18144,22 +12705,14 @@ class MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge
 {
 public:
     MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus value);
 };
@@ -18169,16 +12722,9 @@ class MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscrip
 {
 public:
     MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18194,22 +12740,14 @@ class MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback
 public:
     MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler,
-                                                                                     MTRLocalActionBlock action,
-                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, action,
-                                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                     MTRDeviceController * controller,
-                                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                   keepAlive){};
 
-    MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
+    MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, device, handler, action,
+        MTRCallbackBridge<NullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};
 
     static void
@@ -18222,17 +12760,9 @@ class MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback
 {
 public:
     MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                         true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOtaSoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18248,22 +12778,14 @@ class MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback
 public:
     MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler,
-                                                                                     MTRLocalActionBlock action,
-                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(queue, handler, action,
-                                                                                                   OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                     MTRDeviceController * controller,
-                                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                   keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
+    MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(queue, device, handler, action,
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(queue, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason value);
@@ -18274,17 +12796,9 @@ class MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback
 {
 public:
     MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                         true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18300,21 +12814,16 @@ class MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttribute
 public:
     MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                              ResponseHandler handler,
-                                                                                             MTRLocalActionBlock action,
                                                                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
-            queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+            queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
+    MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                             ResponseHandler handler,
+                                                                                             MTRActionBlock action,
+                                                                                             bool keepAlive = false) :
         MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+            queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -18326,18 +12835,9 @@ class MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttribute
 {
 public:
     MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                                 action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, device, handler, action,
-                                                                                                 true),
+        MTRNullableOtaSoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18352,22 +12852,13 @@ class MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBr
 {
 public:
     MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, device, handler, action,
+    MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum value);
@@ -18378,17 +12869,9 @@ class MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSu
 {
 public:
     MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18404,21 +12887,16 @@ class MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCa
 public:
     MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                            ResponseHandler handler,
-                                                                                           MTRLocalActionBlock action,
                                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, action,
+        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler,
                                                                                                          OnSuccessFn, keepAlive){};
 
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                           ResponseHandler handler,
+                                                                                           MTRActionBlock action,
+                                                                                           bool keepAlive = false) :
+        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, action,
+                                                                                                         OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -18430,18 +12908,9 @@ class MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCa
 {
 public:
     MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                               action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, device, handler, action,
-                                                                                               true),
+        MTRNullableOtaSoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18456,23 +12925,14 @@ class MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBri
 {
 public:
     MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum value);
 };
@@ -18482,17 +12942,9 @@ class MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSub
 {
 public:
     MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18508,22 +12960,17 @@ class MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCal
 public:
     MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
-                                                                                          MTRLocalActionBlock action,
+                                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                        keepAlive){};
+
+    MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                          ResponseHandler handler,
+                                                                                          MTRActionBlock action,
                                                                                           bool keepAlive = false) :
         MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};
 
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void
     OnSuccessFn(void * context,
                 const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum> & value);
@@ -18534,17 +12981,9 @@ class MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCal
 {
 public:
     MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                              action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18559,20 +12998,12 @@ class MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge
 {
 public:
     MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::TimeFormatLocalization::CalendarType value);
@@ -18583,16 +13014,9 @@ class MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionB
 {
 public:
     MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18607,23 +13031,14 @@ class MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridg
 {
 public:
     MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -18635,17 +13050,9 @@ class MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubsc
 {
 public:
     MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18660,20 +13067,12 @@ class MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge
 {
 public:
     MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::TimeFormatLocalization::HourFormat value);
@@ -18684,16 +13083,9 @@ class MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBri
 {
 public:
     MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18708,22 +13100,14 @@ class MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge
 {
 public:
     MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::TimeFormatLocalization::HourFormat> & value);
@@ -18734,16 +13118,9 @@ class MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscri
 {
 public:
     MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18758,20 +13135,12 @@ class MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge
 {
 public:
     MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::UnitLocalization::TempUnit value);
 };
@@ -18780,18 +13149,10 @@ class MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge
     : public MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge
 {
 public:
-    MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18806,20 +13167,12 @@ class MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge
 {
 public:
     MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -18831,16 +13184,9 @@ class MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18855,20 +13201,12 @@ class MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeFault value);
 };
@@ -18877,18 +13215,10 @@ class MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18903,20 +13233,12 @@ class MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -18928,16 +13250,9 @@ class MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBr
 {
 public:
     MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -18952,20 +13267,12 @@ class MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeLevel value);
 };
@@ -18974,18 +13281,10 @@ class MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19000,20 +13299,12 @@ class MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -19025,16 +13316,9 @@ class MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBr
 {
 public:
     MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19049,40 +13333,24 @@ class MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeState value);
 };
 
 class MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge
-    : public MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge
-{
-public:
-    MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    : public MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge
+{
+public:
+    MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19097,20 +13365,12 @@ class MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -19122,16 +13382,9 @@ class MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBr
 {
 public:
     MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19144,19 +13397,12 @@ class MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBr
 class MTRPowerSourceClusterBatFaultAttributeCallbackBridge : public MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>
 {
 public:
-    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatFault value);
 };
@@ -19164,18 +13410,10 @@ class MTRPowerSourceClusterBatFaultAttributeCallbackBridge : public MTRCallbackB
 class MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge : public MTRPowerSourceClusterBatFaultAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterBatFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19190,20 +13428,12 @@ class MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatFault> & value);
@@ -19213,18 +13443,10 @@ class MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge
     : public MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge
 {
 public:
-    MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19239,20 +13461,12 @@ class MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatReplaceability value);
 };
@@ -19262,16 +13476,9 @@ class MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge
 {
 public:
     MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19286,20 +13493,12 @@ class MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -19311,16 +13510,9 @@ class MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptio
 {
 public:
     MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19335,20 +13527,12 @@ class MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::PowerSourceStatus value);
 };
@@ -19358,16 +13542,9 @@ class MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge
 {
 public:
     MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19382,20 +13559,12 @@ class MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -19407,16 +13576,9 @@ class MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptio
 {
 public:
     MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19431,20 +13593,12 @@ class MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::WiredCurrentType value);
 };
@@ -19453,18 +13607,10 @@ class MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19479,20 +13625,12 @@ class MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -19504,16 +13642,9 @@ class MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscription
 {
 public:
     MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19528,18 +13659,12 @@ class MTRPowerSourceClusterWiredFaultAttributeCallbackBridge
 {
 public:
     MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::WiredFault value);
 };
@@ -19548,18 +13673,10 @@ class MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge
     : public MTRPowerSourceClusterWiredFaultAttributeCallbackBridge
 {
 public:
-    MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19574,20 +13691,12 @@ class MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge
 {
 public:
     MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::WiredFault> & value);
@@ -19598,16 +13707,9 @@ class MTRNullablePowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullablePowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19622,22 +13724,13 @@ class MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge
 {
 public:
     MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralCommissioning::CommissioningError value);
 };
@@ -19647,16 +13740,9 @@ class MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscript
 {
 public:
     MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19671,22 +13757,13 @@ class MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackB
 {
 public:
     MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                    MTRLocalActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, action,
-                                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                    MTRDeviceController * controller,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                  keepAlive){};
 
-    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, device, handler, action,
+    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                    MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};
 
     static void
@@ -19699,17 +13776,9 @@ class MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackS
 {
 public:
     MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                        true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19724,23 +13793,14 @@ class MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridg
 {
 public:
     MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType value);
 };
@@ -19750,17 +13810,9 @@ class MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubsc
 {
 public:
     MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19776,23 +13828,16 @@ class MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallb
 public:
     MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
-                                                                                        MTRLocalActionBlock action,
                                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, action,
-                                                                                                      OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                      keepAlive){};
 
-    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                        MTRDeviceController * controller,
+    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
                                                                                         MTRActionBlock action,
                                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, action,
+                                                                                                      OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -19804,17 +13849,9 @@ class MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallb
 {
 public:
     MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                            action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19829,22 +13866,13 @@ class MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackB
 {
 public:
     MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                    MTRLocalActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, action,
-                                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                    MTRDeviceController * controller,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                  keepAlive){};
 
-    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, device, handler, action,
+    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                    MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus value);
@@ -19855,17 +13883,9 @@ class MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackS
 {
 public:
     MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                        true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19881,21 +13901,16 @@ class MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeC
 public:
     MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                             ResponseHandler handler,
-                                                                                            MTRLocalActionBlock action,
                                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, action,
+        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler,
                                                                                                           OnSuccessFn, keepAlive){};
 
-    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                            ResponseHandler handler,
+                                                                                            MTRActionBlock action,
+                                                                                            bool keepAlive = false) :
+        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, action,
+                                                                                                          OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -19907,18 +13922,9 @@ class MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeC
 {
 public:
     MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                                action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, device, handler, action,
-                                                                                                true),
+        MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19933,20 +13939,12 @@ class MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge
 {
 public:
     MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::NetworkCommissioning::WiFiBand value);
 };
@@ -19956,16 +13954,9 @@ class MTRNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -19980,20 +13971,12 @@ class MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge
 {
 public:
     MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -20005,16 +13988,9 @@ class MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptio
 {
 public:
     MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20029,20 +14005,12 @@ class MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
 {
 public:
     MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsIntent value);
 };
@@ -20051,18 +14019,10 @@ class MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge
     : public MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
 {
 public:
-    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20077,20 +14037,12 @@ class MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
 {
 public:
     MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -20102,16 +14054,9 @@ class MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20126,20 +14071,12 @@ class MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
 {
 public:
     MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsStatus value);
 };
@@ -20148,18 +14085,10 @@ class MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge
     : public MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
 {
 public:
-    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20174,20 +14103,12 @@ class MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
 {
 public:
     MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -20199,16 +14120,9 @@ class MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20223,20 +14137,12 @@ class MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge
 {
 public:
     MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol value);
@@ -20247,16 +14153,9 @@ class MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionB
 {
 public:
     MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20271,23 +14170,14 @@ class MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridg
 {
 public:
     MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -20299,17 +14189,9 @@ class MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubsc
 {
 public:
     MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20324,20 +14206,12 @@ class MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::BootReasonType value);
@@ -20348,16 +14222,9 @@ class MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBri
 {
 public:
     MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20372,22 +14239,14 @@ class MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge
 {
 public:
     MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::BootReasonType> & value);
@@ -20398,16 +14257,9 @@ class MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscri
 {
 public:
     MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20422,20 +14274,12 @@ class MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::HardwareFaultType value);
@@ -20446,16 +14290,9 @@ class MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscription
 {
 public:
     MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20470,23 +14307,14 @@ class MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBrid
 {
 public:
     MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -20498,17 +14326,9 @@ class MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubs
 {
 public:
     MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20523,20 +14343,12 @@ class MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::InterfaceType value);
@@ -20547,16 +14359,9 @@ class MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBrid
 {
 public:
     MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20571,22 +14376,14 @@ class MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge
 {
 public:
     MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::InterfaceType> & value);
@@ -20597,16 +14394,9 @@ class MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscrip
 {
 public:
     MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20621,20 +14411,12 @@ class MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::NetworkFaultType value);
@@ -20645,16 +14427,9 @@ class MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionB
 {
 public:
     MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20669,23 +14444,14 @@ class MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridg
 {
 public:
     MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -20697,17 +14463,9 @@ class MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubsc
 {
 public:
     MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20722,20 +14480,12 @@ class MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge
 {
 public:
     MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::RadioFaultType value);
@@ -20746,16 +14496,9 @@ class MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBri
 {
 public:
     MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20770,22 +14513,14 @@ class MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge
 {
 public:
     MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::RadioFaultType> & value);
@@ -20796,16 +14531,9 @@ class MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscri
 {
 public:
     MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20820,20 +14548,12 @@ class MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault value);
@@ -20844,16 +14564,9 @@ class MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptio
 {
 public:
     MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20868,23 +14581,14 @@ class MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBri
 {
 public:
     MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -20896,17 +14600,9 @@ class MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSub
 {
 public:
     MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20921,20 +14617,12 @@ class MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
 {
 public:
     MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole value);
@@ -20945,16 +14633,9 @@ class MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscription
 {
 public:
     MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -20969,23 +14650,14 @@ class MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBrid
 {
 public:
     MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -20997,17 +14669,9 @@ class MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubs
 {
 public:
     MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21022,22 +14686,13 @@ class MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackB
 {
 public:
     MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                    MTRLocalActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, action,
-                                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                    MTRDeviceController * controller,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                  keepAlive){};
 
-    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, device, handler, action,
+    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                    MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus value);
@@ -21048,17 +14703,9 @@ class MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackS
 {
 public:
     MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                        true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21074,21 +14721,16 @@ class MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeC
 public:
     MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                             ResponseHandler handler,
-                                                                                            MTRLocalActionBlock action,
                                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, action,
+        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler,
                                                                                                           OnSuccessFn, keepAlive){};
 
-    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                            ResponseHandler handler,
+                                                                                            MTRActionBlock action,
+                                                                                            bool keepAlive = false) :
+        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, action,
+                                                                                                          OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -21100,18 +14742,9 @@ class MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeC
 {
 public:
     MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                                action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, device, handler, action,
-                                                                                                true),
+        MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21126,22 +14759,13 @@ class MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBr
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, device, handler, action,
+    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause value);
@@ -21152,17 +14776,9 @@ class MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSu
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21178,21 +14794,16 @@ class MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCa
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                            ResponseHandler handler,
-                                                                                           MTRLocalActionBlock action,
                                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, action,
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler,
                                                                                                          OnSuccessFn, keepAlive){};
 
-    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                           ResponseHandler handler,
+                                                                                           MTRActionBlock action,
+                                                                                           bool keepAlive = false) :
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, action,
+                                                                                                         OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -21204,18 +14815,9 @@ class MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCa
 {
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                               action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, device, handler, action,
-                                                                                               true),
+        MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21230,20 +14832,12 @@ class MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType value);
@@ -21254,16 +14848,9 @@ class MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionB
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21278,23 +14865,14 @@ class MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridg
 {
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -21306,17 +14884,9 @@ class MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubsc
 {
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21331,23 +14901,14 @@ class MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridg
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus value);
 };
@@ -21357,17 +14918,9 @@ class MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubsc
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21383,23 +14936,16 @@ class MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallb
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
-                                                                                        MTRLocalActionBlock action,
                                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, action,
-                                                                                                      OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                      keepAlive){};
 
-    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                        MTRDeviceController * controller,
+    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
                                                                                         MTRActionBlock action,
                                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, action,
+                                                                                                      OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -21411,17 +14957,9 @@ class MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallb
 {
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                            action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21436,22 +14974,13 @@ class MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType value);
 };
@@ -21461,16 +14990,9 @@ class MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscripti
 {
 public:
     MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21485,22 +15007,13 @@ class MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBr
 {
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, device, handler, action,
+    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void
@@ -21513,17 +15026,9 @@ class MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSu
 {
 public:
     MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21538,22 +15043,13 @@ class MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge
 {
 public:
     MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType value);
 };
@@ -21563,16 +15059,9 @@ class MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscripti
 {
 public:
     MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21587,22 +15076,13 @@ class MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBr
 {
 public:
     MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, device, handler, action,
+    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void
@@ -21615,17 +15095,9 @@ class MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSu
 {
 public:
     MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21640,20 +15112,12 @@ class MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge
 {
 public:
     MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::TimeSynchronization::GranularityEnum value);
@@ -21664,16 +15128,9 @@ class MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionB
 {
 public:
     MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21688,23 +15145,14 @@ class MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridg
 {
 public:
     MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -21716,17 +15164,9 @@ class MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackSubsc
 {
 public:
     MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21741,20 +15181,12 @@ class MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge
 {
 public:
     MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value);
@@ -21765,16 +15197,9 @@ class MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBr
 {
 public:
     MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21789,22 +15214,14 @@ class MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge
 {
 public:
     MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                             keepAlive){};
-
-    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                               MTRDeviceController * controller,
-                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                             action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                             keepAlive){};
 
-    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                               ResponseHandler handler, MTRActionBlock action,
-                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, device, handler, action,
-                                                                                             OnSuccessFn, keepAlive){};
+    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                               MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                             keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::TimeSourceEnum> & value);
@@ -21815,17 +15232,9 @@ class MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscr
 {
 public:
     MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                   true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21841,22 +15250,17 @@ class MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCall
 public:
     MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
-                                                                                         MTRLocalActionBlock action,
+                                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                       keepAlive){};
+
+    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                         ResponseHandler handler,
+                                                                                         MTRActionBlock action,
                                                                                          bool keepAlive = false) :
         MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};
 
-    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus value);
 };
 
@@ -21865,17 +15269,9 @@ class MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCall
 {
 public:
     MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                             action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21891,21 +15287,16 @@ class MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttri
 public:
     MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                                  ResponseHandler handler,
-                                                                                                 MTRLocalActionBlock action,
                                                                                                  bool keepAlive = false) :
         MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
-            queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+            queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
+    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                                 ResponseHandler handler,
+                                                                                                 MTRActionBlock action,
+                                                                                                 bool keepAlive = false) :
         MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+            queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -21917,18 +15308,9 @@ class MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttri
 {
 public:
     MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, nodeID, controller,
-                                                                                                     handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, device, handler, action,
-                                                                                                     true),
+        MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21943,20 +15325,12 @@ class MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge
 {
 public:
     MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::AdministratorCommissioning::StatusCode value);
@@ -21967,16 +15341,9 @@ class MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptio
 {
 public:
     MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -21991,23 +15358,14 @@ class MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBri
 {
 public:
     MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -22019,17 +15377,9 @@ class MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSub
 {
 public:
     MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22044,23 +15394,14 @@ class MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBrid
 {
 public:
     MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::OperationalCredentials::OperationalCertStatus value);
 };
@@ -22070,17 +15411,9 @@ class MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubs
 {
 public:
     MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22096,22 +15429,17 @@ class MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCall
 public:
     MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
-                                                                                         MTRLocalActionBlock action,
+                                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                       keepAlive){};
+
+    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                         ResponseHandler handler,
+                                                                                         MTRActionBlock action,
                                                                                          bool keepAlive = false) :
         MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};
 
-    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void
     OnSuccessFn(void * context,
                 const chip::app::DataModel::Nullable<chip::app::Clusters::OperationalCredentials::OperationalCertStatus> & value);
@@ -22122,17 +15450,9 @@ class MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCall
 {
 public:
     MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                             action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22147,22 +15467,14 @@ class MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge
 {
 public:
     MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy value);
 };
@@ -22172,16 +15484,9 @@ class MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscri
 {
 public:
     MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22197,22 +15502,15 @@ class MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbac
 public:
     MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                       ResponseHandler handler,
-                                                                                      MTRLocalActionBlock action,
                                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, action,
-                                                                                                    OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                    keepAlive){};
 
-    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                      MTRDeviceController * controller,
+    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                       ResponseHandler handler,
                                                                                       MTRActionBlock action,
                                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, device, handler, action,
+        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, action,
                                                                                                     OnSuccessFn, keepAlive){};
 
     static void
@@ -22225,17 +15523,9 @@ class MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbac
 {
 public:
     MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                          action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22248,19 +15538,12 @@ class MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbac
 class MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
-
-    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlAlarmCode value);
 };
@@ -22268,18 +15551,10 @@ class MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge : public MTRCallbackB
 class MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22294,20 +15569,12 @@ class MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlAlarmCode> & value);
@@ -22317,18 +15584,10 @@ class MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge
     : public MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge
 {
 public:
-    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22343,20 +15602,12 @@ class MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlCredentialRule value);
 };
@@ -22365,18 +15616,10 @@ class MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22391,20 +15634,12 @@ class MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -22416,16 +15651,9 @@ class MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22440,20 +15668,12 @@ class MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlCredentialType value);
 };
@@ -22462,18 +15682,10 @@ class MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22488,20 +15700,12 @@ class MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -22513,16 +15717,9 @@ class MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22537,20 +15734,12 @@ class MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDataOperationType value);
 };
@@ -22559,18 +15748,10 @@ class MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22585,20 +15766,12 @@ class MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -22610,16 +15783,9 @@ class MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscription
 {
 public:
     MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22632,38 +15798,23 @@ class MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscription
 class MTRDoorLockClusterDlDoorStateAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
-
-    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDoorState value);
 };
 
 class MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlDoorStateAttributeCallbackBridge
 {
-public:
-    MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
-                                                                     MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
+public:
+    MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                     MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22678,20 +15829,12 @@ class MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlDoorState> & value);
@@ -22701,18 +15844,10 @@ class MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge
     : public MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge
 {
 public:
-    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22727,18 +15862,12 @@ class MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                            MTRDeviceController * controller, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                          keepAlive){};
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                            MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                            bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockDataType value);
 };
@@ -22747,18 +15876,10 @@ class MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22773,20 +15894,12 @@ class MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockDataType> & value);
@@ -22797,16 +15910,9 @@ class MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridg
 {
 public:
     MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22821,20 +15927,12 @@ class MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockOperationType value);
 };
@@ -22843,18 +15941,10 @@ class MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22869,20 +15959,12 @@ class MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -22894,16 +15976,9 @@ class MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscription
 {
 public:
     MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22916,19 +15991,12 @@ class MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscription
 class MTRDoorLockClusterDlLockStateAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                         MTRDeviceController * controller, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                       keepAlive){};
+    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                         bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockState value);
 };
@@ -22936,18 +16004,10 @@ class MTRDoorLockClusterDlLockStateAttributeCallbackBridge : public MTRCallbackB
 class MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlLockStateAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockStateAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlLockStateAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -22962,20 +16022,12 @@ class MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value);
@@ -22985,18 +16037,10 @@ class MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge
     : public MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge
 {
 public:
-    MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23009,38 +16053,23 @@ class MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge
 class MTRDoorLockClusterDlLockTypeAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockType value);
 };
 
 class MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlLockTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23055,20 +16084,12 @@ class MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockType> & value);
@@ -23078,18 +16099,10 @@ class MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge
     : public MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge
 {
 public:
-    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23104,20 +16117,12 @@ class MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperatingMode value);
 };
@@ -23126,18 +16131,10 @@ class MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23152,20 +16149,12 @@ class MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -23177,16 +16166,9 @@ class MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBrid
 {
 public:
     MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23201,20 +16183,12 @@ class MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperationError value);
 };
@@ -23223,18 +16197,10 @@ class MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23249,20 +16215,12 @@ class MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -23274,16 +16232,9 @@ class MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23298,20 +16249,12 @@ class MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperationSource value);
 };
@@ -23320,18 +16263,10 @@ class MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23346,20 +16281,12 @@ class MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -23371,16 +16298,9 @@ class MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBr
 {
 public:
     MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23393,37 +16313,23 @@ class MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBr
 class MTRDoorLockClusterDlStatusAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                       bool keepAlive = false) :
         MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
-                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                    keepAlive){};
-
-    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlStatus value);
 };
 
 class MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlStatusAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23438,20 +16344,12 @@ class MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlStatus> & value);
 };
@@ -23460,18 +16358,10 @@ class MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge
     : public MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge
 {
 public:
-    MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23484,19 +16374,12 @@ class MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge
 class MTRDoorLockClusterDlUserStatusAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                          MTRDeviceController * controller, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                        keepAlive){};
+    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                          bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlUserStatus value);
 };
@@ -23505,18 +16388,10 @@ class MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDlUserStatusAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23531,20 +16406,12 @@ class MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlUserStatus> & value);
@@ -23555,16 +16422,9 @@ class MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23577,38 +16437,23 @@ class MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge
 class MTRDoorLockClusterDlUserTypeAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>
 {
 public:
-    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlUserType value);
 };
 
 class MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlUserTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23623,20 +16468,12 @@ class MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlUserType> & value);
@@ -23646,18 +16483,10 @@ class MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge
     : public MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge
 {
 public:
-    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23672,20 +16501,12 @@ class MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockOperationEventCode value);
@@ -23696,16 +16517,9 @@ class MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionB
 {
 public:
     MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23720,23 +16534,14 @@ class MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridg
 {
 public:
     MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -23748,17 +16553,9 @@ class MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubsc
 {
 public:
     MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23773,20 +16570,12 @@ class MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode value);
@@ -23797,16 +16586,9 @@ class MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptio
 {
 public:
     MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23821,23 +16603,14 @@ class MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBri
 {
 public:
     MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -23849,17 +16622,9 @@ class MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSub
 {
 public:
     MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23874,20 +16639,12 @@ class MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus value);
@@ -23898,16 +16655,9 @@ class MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBri
 {
 public:
     MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23922,22 +16672,14 @@ class MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus> & value);
@@ -23948,16 +16690,9 @@ class MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscri
 {
 public:
     MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -23972,20 +16707,12 @@ class MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockUserStatus value);
 };
@@ -23994,18 +16721,10 @@ class MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24020,20 +16739,12 @@ class MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                      keepAlive){};
+                                                                        bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                        MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                      OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                        ResponseHandler handler, MTRActionBlock action,
-                                                                        bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -24045,16 +16756,9 @@ class MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionB
 {
 public:
     MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24069,20 +16773,12 @@ class MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
 {
 public:
     MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockUserType value);
 };
@@ -24091,18 +16787,10 @@ class MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge
     : public MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
 {
 public:
-    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24117,20 +16805,12 @@ class MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
 {
 public:
     MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -24142,16 +16822,9 @@ class MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24166,20 +16839,12 @@ class MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge
 {
 public:
     MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::WindowCovering::EndProductType value);
 };
@@ -24189,16 +16854,9 @@ class MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24213,20 +16871,12 @@ class MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge
 {
 public:
     MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -24238,16 +16888,9 @@ class MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptio
 {
 public:
     MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24260,38 +16903,23 @@ class MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptio
 class MTRWindowCoveringClusterTypeAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>
 {
 public:
-    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
+    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, bool keepAlive = false) :
+        MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
+
+    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                         bool keepAlive = false) :
         MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
-    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                        MTRDeviceController * controller, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                      keepAlive){};
-
-    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void OnSuccessFn(void * context, chip::app::Clusters::WindowCovering::Type value);
 };
 
 class MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge : public MTRWindowCoveringClusterTypeAttributeCallbackBridge
 {
 public:
-    MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24306,20 +16934,12 @@ class MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge
 {
 public:
     MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                bool keepAlive = false) :
+        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                              OnSuccessFn, keepAlive){};
-
-    MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                bool keepAlive = false) :
-        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                              keepAlive){};
+        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::WindowCovering::Type> & value);
@@ -24329,18 +16949,10 @@ class MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge
     : public MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge
 {
 public:
-    MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
+    MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24355,23 +16967,14 @@ class MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridg
 {
 public:
     MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                               keepAlive){};
 
-    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                MTRDeviceController * controller,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                              action, OnSuccessFn, keepAlive){};
-
-    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                ResponseHandler handler, MTRActionBlock action,
-                                                                                bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, device, handler, action,
-                                                                                              OnSuccessFn, keepAlive){};
+    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                              keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode value);
 };
@@ -24381,17 +16984,9 @@ class MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubsc
 {
 public:
     MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                    true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24407,23 +17002,16 @@ class MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallb
 public:
     MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
-                                                                                        MTRLocalActionBlock action,
                                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, action,
-                                                                                                      OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                      keepAlive){};
 
-    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                        MTRDeviceController * controller,
+    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
                                                                                         MTRActionBlock action,
                                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, action,
+                                                                                                      OnSuccessFn, keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -24435,17 +17023,9 @@ class MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallb
 {
 public:
     MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                            action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24460,23 +17040,14 @@ class MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBri
 {
 public:
     MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode value);
 };
@@ -24486,17 +17057,9 @@ class MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSub
 {
 public:
     MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24512,22 +17075,17 @@ class MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCal
 public:
     MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
-                                                                                          MTRLocalActionBlock action,
+                                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                        keepAlive){};
+
+    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                          ResponseHandler handler,
+                                                                                          MTRActionBlock action,
                                                                                           bool keepAlive = false) :
         MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};
 
-    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
-
     static void
     OnSuccessFn(void * context,
                 const chip::app::DataModel::Nullable<chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode> & value);
@@ -24538,17 +17096,9 @@ class MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCal
 {
 public:
     MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                              action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24563,20 +17113,12 @@ class MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge
 {
 public:
     MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::SetpointAdjustMode value);
 };
@@ -24586,16 +17128,9 @@ class MTRThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24610,20 +17145,12 @@ class MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge
 {
 public:
     MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -24635,16 +17162,9 @@ class MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptio
 {
 public:
     MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24659,20 +17179,12 @@ class MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge
 {
 public:
     MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::ThermostatControlSequence value);
@@ -24683,16 +17195,9 @@ class MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscription
 {
 public:
     MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24707,23 +17212,14 @@ class MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBrid
 {
 public:
     MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                 MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                keepAlive){};
 
-    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                 MTRDeviceController * controller,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                               action, OnSuccessFn, keepAlive){};
-
-    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, device, handler, action,
-                                                                                               OnSuccessFn, keepAlive){};
+    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                 MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                               keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -24735,17 +17231,9 @@ class MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackSubs
 {
 public:
     MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                     true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24760,20 +17248,12 @@ class MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge
 {
 public:
     MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::ThermostatRunningMode value);
@@ -24784,16 +17264,9 @@ class MTRThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBrid
 {
 public:
     MTRThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24808,22 +17281,14 @@ class MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge
 {
 public:
     MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                           keepAlive){};
-
-    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                           action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                           keepAlive){};
 
-    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, device, handler, action,
-                                                                                           OnSuccessFn, keepAlive){};
+    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                           keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatRunningMode> & value);
@@ -24834,16 +17299,9 @@ class MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackSubscrip
 {
 public:
     MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24858,20 +17316,12 @@ class MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge
 {
 public:
     MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::ThermostatSystemMode value);
 };
@@ -24881,16 +17331,9 @@ class MTRThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridg
 {
 public:
     MTRThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24905,22 +17348,13 @@ class MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge
 {
 public:
     MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatSystemMode> & value);
@@ -24931,16 +17365,9 @@ class MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackSubscript
 {
 public:
     MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -24955,20 +17382,12 @@ class MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge
 {
 public:
     MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::FanControl::FanModeSequenceType value);
 };
@@ -24978,16 +17397,9 @@ class MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25002,22 +17414,13 @@ class MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge
 {
 public:
     MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::FanControl::FanModeSequenceType> & value);
@@ -25028,16 +17431,9 @@ class MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackSubscripti
 {
 public:
     MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25052,18 +17448,12 @@ class MTRFanControlClusterFanModeTypeAttributeCallbackBridge
 {
 public:
     MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::FanControl::FanModeType value);
 };
@@ -25072,18 +17462,10 @@ class MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge
     : public MTRFanControlClusterFanModeTypeAttributeCallbackBridge
 {
 public:
-    MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25098,20 +17480,12 @@ class MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge
 {
 public:
     MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::FanControl::FanModeType> & value);
@@ -25122,16 +17496,9 @@ class MTRNullableFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25146,20 +17513,12 @@ class MTRColorControlClusterColorLoopActionAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                 bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                 MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                               OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                 ResponseHandler handler, MTRActionBlock action,
-                                                                 bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                               keepAlive){};
+        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorLoopAction value);
 };
@@ -25168,18 +17527,10 @@ class MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge
     : public MTRColorControlClusterColorLoopActionAttributeCallbackBridge
 {
 public:
-    MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                             MTRDeviceController * controller,
-                                                                             ResponseHandler handler, MTRActionBlock action,
-                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterColorLoopActionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                             MTRActionBlock action,
                                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterColorLoopActionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterColorLoopActionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25194,20 +17545,12 @@ class MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                       keepAlive){};
+                                                                         bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                       OnSuccessFn, keepAlive){};
-
-    MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -25219,16 +17562,9 @@ class MTRNullableColorControlClusterColorLoopActionAttributeCallbackSubscription
 {
 public:
     MTRNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25243,20 +17579,12 @@ class MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorLoopDirection value);
 };
@@ -25266,16 +17594,9 @@ class MTRColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridg
 {
 public:
     MTRColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25290,22 +17611,13 @@ class MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorLoopDirection> & value);
@@ -25316,16 +17628,9 @@ class MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscript
 {
 public:
     MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25340,18 +17645,12 @@ class MTRColorControlClusterColorModeAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorMode value);
 };
@@ -25360,18 +17659,10 @@ class MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge
     : public MTRColorControlClusterColorModeAttributeCallbackBridge
 {
 public:
-    MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterColorModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterColorModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterColorModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25386,20 +17677,12 @@ class MTRNullableColorControlClusterColorModeAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorMode> & value);
@@ -25410,16 +17693,9 @@ class MTRNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterColorModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterColorModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterColorModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25434,20 +17710,12 @@ class MTRColorControlClusterHueDirectionAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueDirection value);
 };
@@ -25456,18 +17724,10 @@ class MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge
     : public MTRColorControlClusterHueDirectionAttributeCallbackBridge
 {
 public:
-    MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterHueDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterHueDirectionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterHueDirectionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25482,20 +17742,12 @@ class MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -25507,16 +17759,9 @@ class MTRNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25531,20 +17776,12 @@ class MTRColorControlClusterHueMoveModeAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueMoveMode value);
 };
@@ -25553,18 +17790,10 @@ class MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge
     : public MTRColorControlClusterHueMoveModeAttributeCallbackBridge
 {
 public:
-    MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterHueMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterHueMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterHueMoveModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25579,20 +17808,12 @@ class MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -25604,16 +17825,9 @@ class MTRNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBrid
 {
 public:
     MTRNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25628,20 +17842,12 @@ class MTRColorControlClusterHueStepModeAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueStepMode value);
 };
@@ -25650,18 +17856,10 @@ class MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge
     : public MTRColorControlClusterHueStepModeAttributeCallbackBridge
 {
 public:
-    MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterHueStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterHueStepModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterHueStepModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25676,20 +17874,12 @@ class MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -25701,16 +17891,9 @@ class MTRNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBrid
 {
 public:
     MTRNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25725,20 +17908,12 @@ class MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::SaturationMoveMode value);
 };
@@ -25748,16 +17923,9 @@ class MTRColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridg
 {
 public:
     MTRColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25772,22 +17940,13 @@ class MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::SaturationMoveMode> & value);
@@ -25798,16 +17957,9 @@ class MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscript
 {
 public:
     MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25822,20 +17974,12 @@ class MTRColorControlClusterSaturationStepModeAttributeCallbackBridge
 {
 public:
     MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::SaturationStepMode value);
 };
@@ -25845,16 +17989,9 @@ class MTRColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridg
 {
 public:
     MTRColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25869,22 +18006,13 @@ class MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge
 {
 public:
     MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::SaturationStepMode> & value);
@@ -25895,16 +18023,9 @@ class MTRNullableColorControlClusterSaturationStepModeAttributeCallbackSubscript
 {
 public:
     MTRNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25919,22 +18040,13 @@ class MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge
 {
 public:
     MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::IlluminanceMeasurement::LightSensorType value);
 };
@@ -25944,16 +18056,9 @@ class MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscripti
 {
 public:
     MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -25968,22 +18073,13 @@ class MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBr
 {
 public:
     MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, device, handler, action,
+    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void
@@ -25996,17 +18092,9 @@ class MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSu
 {
 public:
     MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26021,20 +18109,12 @@ class MTRChannelClusterChannelStatusEnumAttributeCallbackBridge
 {
 public:
     MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                              bool keepAlive = false) :
+        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                              MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
-
-    MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                              ResponseHandler handler, MTRActionBlock action,
-                                                              bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                            keepAlive){};
+        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Channel::ChannelStatusEnum value);
 };
@@ -26043,18 +18123,10 @@ class MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge
     : public MTRChannelClusterChannelStatusEnumAttributeCallbackBridge
 {
 public:
-    MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26069,20 +18141,12 @@ class MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge
 {
 public:
     MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -26094,16 +18158,9 @@ class MTRNullableChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBri
 {
 public:
     MTRNullableChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26118,20 +18175,12 @@ class MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
 {
 public:
     MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::Channel::LineupInfoTypeEnum value);
 };
@@ -26140,18 +18189,10 @@ class MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge
     : public MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
 {
 public:
-    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26166,20 +18207,12 @@ class MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -26191,16 +18224,9 @@ class MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBr
 {
 public:
     MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26215,22 +18241,14 @@ class MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge
 {
 public:
     MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::TargetNavigator::TargetNavigatorStatusEnum value);
 };
@@ -26240,16 +18258,9 @@ class MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscri
 {
 public:
     MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26265,22 +18276,15 @@ class MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbac
 public:
     MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                       ResponseHandler handler,
-                                                                                      MTRLocalActionBlock action,
                                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, action,
-                                                                                                    OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                    keepAlive){};
 
-    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                      MTRDeviceController * controller,
+    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                       ResponseHandler handler,
                                                                                       MTRActionBlock action,
                                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, device, handler, action,
+        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                     OnSuccessFn, keepAlive){};
 
     static void
@@ -26293,17 +18297,9 @@ class MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbac
 {
 public:
     MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                          action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26318,20 +18314,12 @@ class MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
 {
 public:
     MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::MediaPlayback::MediaPlaybackStatusEnum value);
@@ -26339,19 +18327,12 @@ class MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
 
 class MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge
     : public MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
-{
-public:
-    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
+{
+public:
     MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26366,23 +18347,14 @@ class MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBri
 {
 public:
     MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                  MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
                                                                                                 keepAlive){};
 
-    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                  MTRDeviceController * controller,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                action, OnSuccessFn, keepAlive){};
-
-    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, device, handler, action,
-                                                                                                OnSuccessFn, keepAlive){};
+    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                  MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                                keepAlive){};
 
     static void
     OnSuccessFn(void * context,
@@ -26394,17 +18366,9 @@ class MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSub
 {
 public:
     MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                      true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26419,20 +18383,12 @@ class MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge
 {
 public:
     MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                    bool keepAlive = false) :
+        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                    MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                  keepAlive){};
+        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value);
 };
@@ -26442,16 +18398,9 @@ class MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridg
 {
 public:
     MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26466,22 +18415,13 @@ class MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge
 {
 public:
     MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::PlaybackStateEnum> & value);
@@ -26492,16 +18432,9 @@ class MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscript
 {
 public:
     MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26516,20 +18449,12 @@ class MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge
 {
 public:
     MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::MediaInput::InputTypeEnum value);
 };
@@ -26538,18 +18463,10 @@ class MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge
     : public MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge
 {
 public:
-    MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26564,20 +18481,12 @@ class MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -26589,16 +18498,9 @@ class MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBrid
 {
 public:
     MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26613,18 +18515,12 @@ class MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge
 {
 public:
     MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
-
-    MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::KeypadInput::CecKeyCode value);
 };
@@ -26633,18 +18529,10 @@ class MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge
     : public MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge
 {
 public:
-    MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26659,20 +18547,12 @@ class MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge
 {
 public:
     MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::KeypadInput::CecKeyCode> & value);
@@ -26683,16 +18563,9 @@ class MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26707,20 +18580,12 @@ class MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge
 {
 public:
     MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                    keepAlive){};
+                                                                      bool keepAlive = false) :
+        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                      MTRDeviceController * controller, ResponseHandler handler,
+    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                    OnSuccessFn, keepAlive){};
-
-    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                      ResponseHandler handler, MTRActionBlock action,
-                                                                      bool keepAlive = false) :
-        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::KeypadInput::KeypadInputStatusEnum value);
@@ -26731,16 +18596,9 @@ class MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBri
 {
 public:
     MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26755,22 +18613,14 @@ class MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge
 {
 public:
     MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                            keepAlive){};
-
-    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                              MTRDeviceController * controller,
-                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
-        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                            action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                            keepAlive){};
 
-    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                              ResponseHandler handler, MTRActionBlock action,
-                                                                              bool keepAlive = false) :
-        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, device, handler, action,
-                                                                                            OnSuccessFn, keepAlive){};
+    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                              MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                            keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::KeypadInput::KeypadInputStatusEnum> & value);
@@ -26781,16 +18631,9 @@ class MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscri
 {
 public:
     MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26805,22 +18648,13 @@ class MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge
 {
 public:
     MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                          keepAlive){};
-
-    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                            MTRDeviceController * controller,
-                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                          action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                            ResponseHandler handler, MTRActionBlock action,
-                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, device, handler, action,
-                                                                                          OnSuccessFn, keepAlive){};
+    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                            MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                          keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ContentLaunchStatusEnum value);
 };
@@ -26830,16 +18664,9 @@ class MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscript
 {
 public:
     MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26854,22 +18681,13 @@ class MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackB
 {
 public:
     MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                    MTRLocalActionBlock action,
                                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, action,
-                                                                                                  OnSuccessFn, keepAlive){};
-
-    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                    MTRDeviceController * controller,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                  keepAlive){};
 
-    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                    ResponseHandler handler, MTRActionBlock action,
-                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, device, handler, action,
+    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                    MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};
 
     static void
@@ -26882,17 +18700,9 @@ class MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackS
 {
 public:
     MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                        true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26907,20 +18717,12 @@ class MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge
 {
 public:
     MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::MetricTypeEnum value);
 };
@@ -26930,16 +18732,9 @@ class MTRContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge
 {
 public:
     MTRContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -26954,22 +18749,13 @@ class MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::MetricTypeEnum> & value);
@@ -26980,16 +18766,9 @@ class MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackSubscripti
 {
 public:
     MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27004,20 +18783,12 @@ class MTRContentLauncherClusterParameterEnumAttributeCallbackBridge
 {
 public:
     MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                  bool keepAlive = false) :
+        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                  MTRDeviceController * controller, ResponseHandler handler,
+    MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                OnSuccessFn, keepAlive){};
-
-    MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                  ResponseHandler handler, MTRActionBlock action,
-                                                                  bool keepAlive = false) :
-        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                keepAlive){};
+        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ParameterEnum value);
 };
@@ -27027,16 +18798,9 @@ class MTRContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge
 {
 public:
     MTRContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27051,20 +18815,12 @@ class MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge
 {
 public:
     MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                        keepAlive){};
+                                                                          bool keepAlive = false) :
+        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                          MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                        OnSuccessFn, keepAlive){};
-
-    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                          ResponseHandler handler, MTRActionBlock action,
-                                                                          bool keepAlive = false) :
-        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -27076,16 +18832,9 @@ class MTRNullableContentLauncherClusterParameterEnumAttributeCallbackSubscriptio
 {
 public:
     MTRNullableContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27100,20 +18849,12 @@ class MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
 {
 public:
     MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                               MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                               bool keepAlive = false) :
+        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                               MTRDeviceController * controller, ResponseHandler handler,
+    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                             OnSuccessFn, keepAlive){};
-
-    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                               ResponseHandler handler, MTRActionBlock action,
-                                                               bool keepAlive = false) :
-        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                             keepAlive){};
+        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::AudioOutput::OutputTypeEnum value);
 };
@@ -27122,18 +18863,10 @@ class MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge
     : public MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
 {
 public:
-    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
+    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27148,20 +18881,12 @@ class MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
 {
 public:
     MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                     keepAlive){};
+                                                                       bool keepAlive = false) :
+        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                     OnSuccessFn, keepAlive){};
-
-    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -27173,16 +18898,9 @@ class MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBr
 {
 public:
     MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27198,22 +18916,15 @@ class MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbac
 public:
     MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                       ResponseHandler handler,
-                                                                                      MTRLocalActionBlock action,
                                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(queue, handler, action,
-                                                                                                    OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                    keepAlive){};
 
-    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                      MTRDeviceController * controller,
+    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                       ResponseHandler handler,
                                                                                       MTRActionBlock action,
                                                                                       bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(queue, device, handler, action,
+        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                     OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatusEnum value);
@@ -27224,17 +18935,9 @@ class MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbac
 {
 public:
     MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
-                                                                                          action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27250,21 +18953,16 @@ class MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttribut
 public:
     MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                               ResponseHandler handler,
-                                                                                              MTRLocalActionBlock action,
                                                                                               bool keepAlive = false) :
         MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
-            queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
-            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};
+            queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
+    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
+                                                                                              ResponseHandler handler,
+                                                                                              MTRActionBlock action,
+                                                                                              bool keepAlive = false) :
         MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
-            queue, device, handler, action, OnSuccessFn, keepAlive){};
+            queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(
         void * context,
@@ -27276,18 +18974,9 @@ class MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttribut
 {
 public:
     MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, nodeID, controller,
-                                                                                                  handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, device, handler, action,
-                                                                                                  true),
+        MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27302,22 +18991,13 @@ class MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge
 {
 public:
     MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                         keepAlive){};
-
-    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                           MTRDeviceController * controller,
-                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                           ResponseHandler handler, MTRActionBlock action,
-                                                                           bool keepAlive = false) :
-        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, device, handler, action,
-                                                                                         OnSuccessFn, keepAlive){};
+    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                           MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
+                                                                                         keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value);
 };
@@ -27327,16 +19007,9 @@ class MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscripti
 {
 public:
     MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27351,22 +19024,13 @@ class MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBr
 {
 public:
     MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                                   MTRLocalActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, action,
-                                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                                   MTRDeviceController * controller,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
-        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
-                                                                                                 action, OnSuccessFn, keepAlive){};
+        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, OnSuccessFn,
+                                                                                                 keepAlive){};
 
-    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, device, handler, action,
+    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+                                                                                   MTRActionBlock action, bool keepAlive = false) :
+        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};
 
     static void
@@ -27379,17 +19043,9 @@ class MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackSu
 {
 public:
     MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
-                                                                                       true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27404,18 +19060,12 @@ class MTRTestClusterClusterSimpleEnumAttributeCallbackBridge
 {
 public:
     MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                           MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                           MTRDeviceController * controller, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                         keepAlive){};
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
-                                                           MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};
+    MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
+                                                           bool keepAlive = false) :
+        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::TestCluster::SimpleEnum value);
 };
@@ -27424,18 +19074,10 @@ class MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge
     : public MTRTestClusterClusterSimpleEnumAttributeCallbackBridge
 {
 public:
-    MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                       MTRDeviceController * controller, ResponseHandler handler,
+    MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                       ResponseHandler handler, MTRActionBlock action,
-                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27450,20 +19092,12 @@ class MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge
 {
 public:
     MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
+                                                                   bool keepAlive = false) :
+        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                   MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                 OnSuccessFn, keepAlive){};
-
-    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                   ResponseHandler handler, MTRActionBlock action,
-                                                                   bool keepAlive = false) :
-        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                                 keepAlive){};
+        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context,
                             const chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::SimpleEnum> & value);
@@ -27474,16 +19108,9 @@ class MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge
 {
 public:
     MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27498,20 +19125,12 @@ class MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge
 {
 public:
     MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                             MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
-
-    MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                             MTRDeviceController * controller, ResponseHandler handler,
-                                                             MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+                                                             bool keepAlive = false) :
+        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                             ResponseHandler handler, MTRActionBlock action,
+    MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
-        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
-                                                                           keepAlive){};
+        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};
 
     static void OnSuccessFn(void * context, chip::app::Clusters::FaultInjection::FaultType value);
 };
@@ -27520,18 +19139,10 @@ class MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge
     : public MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge
 {
 public:
-    MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                         MTRDeviceController * controller, ResponseHandler handler,
+    MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                         ResponseHandler handler, MTRActionBlock action,
-                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
@@ -27546,20 +19157,12 @@ class MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge
 {
 public:
     MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
-                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
-                                                                                   keepAlive){};
+                                                                     bool keepAlive = false) :
+        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, OnSuccessFn, keepAlive){};
 
-    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
-                                                                     MTRDeviceController * controller, ResponseHandler handler,
+    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
-        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
-                                                                                   OnSuccessFn, keepAlive){};
-
-    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
-                                                                     ResponseHandler handler, MTRActionBlock action,
-                                                                     bool keepAlive = false) :
-        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
+        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};
 
     static void OnSuccessFn(void * context,
@@ -27571,16 +19174,9 @@ class MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBrid
 {
 public:
     MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
-        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
-        mEstablishedHandler(establishedHandler)
-    {}
-
-    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(
-        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
+        dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action,
         MTRSubscriptionEstablishedHandler establishedHandler) :
-        MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
+        MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, handler, action, true),
         mEstablishedHandler(establishedHandler)
     {}
 
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
index e743f51416f9fe..5055f414bc45a7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
@@ -70,13 +70,14 @@ - (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Identify::Commands::Identify::Type request;
@@ -85,12 +86,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.identifyTime = params.identifyTime.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -120,13 +119,14 @@ - (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Identify::Commands::TriggerEffect::Type request;
@@ -138,12 +138,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.effectVariant
                     = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -294,8 +292,9 @@ - (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterAddGroupResponseCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Groups::Commands::AddGroup::Type request;
@@ -305,12 +304,10 @@ new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, baseDevic
                 request.groupId = params.groupId.unsignedShortValue;
                 request.groupName = [self asCharSpan:params.groupName];
 
-                auto successFn = Callback<GroupsClusterAddGroupResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -341,8 +338,9 @@ - (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GroupsClusterViewGroupResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Groups::Commands::ViewGroup::Type request;
@@ -351,12 +349,10 @@ new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, baseDevi
                 }
                 request.groupId = params.groupId.unsignedShortValue;
 
-                auto successFn = Callback<GroupsClusterViewGroupResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -387,8 +383,10 @@ - (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GroupsClusterGetGroupMembershipResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Groups::Commands::GetGroupMembership::Type request;
@@ -418,12 +416,10 @@ new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue,
                     }
                 }
 
-                auto successFn = Callback<GroupsClusterGetGroupMembershipResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -454,8 +450,10 @@ - (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GroupsClusterRemoveGroupResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Groups::Commands::RemoveGroup::Type request;
@@ -464,12 +462,10 @@ new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, baseDe
                 }
                 request.groupId = params.groupId.unsignedShortValue;
 
-                auto successFn = Callback<GroupsClusterRemoveGroupResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -508,13 +504,14 @@ - (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Null
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Groups::Commands::RemoveAllGroups::Type request;
@@ -522,12 +519,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -557,13 +552,14 @@ - (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingPa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Groups::Commands::AddGroupIfIdentifying::Type request;
@@ -573,12 +569,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.groupId = params.groupId.unsignedShortValue;
                 request.groupName = [self asCharSpan:params.groupName];
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -754,8 +748,9 @@ - (void)addSceneWithParams:(MTRScenesClusterAddSceneParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterAddSceneResponseCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::AddScene::Type request;
@@ -841,12 +836,10 @@ new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, baseDevic
                     }
                 }
 
-                auto successFn = Callback<ScenesClusterAddSceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -877,8 +870,9 @@ - (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterViewSceneResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::ViewScene::Type request;
@@ -888,12 +882,10 @@ new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, baseDevi
                 request.groupId = params.groupId.unsignedShortValue;
                 request.sceneId = params.sceneId.unsignedCharValue;
 
-                auto successFn = Callback<ScenesClusterViewSceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -924,8 +916,10 @@ - (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterRemoveSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::RemoveScene::Type request;
@@ -935,12 +929,10 @@ new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, baseDe
                 request.groupId = params.groupId.unsignedShortValue;
                 request.sceneId = params.sceneId.unsignedCharValue;
 
-                auto successFn = Callback<ScenesClusterRemoveSceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -971,8 +963,10 @@ - (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)param
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterRemoveAllScenesResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::RemoveAllScenes::Type request;
@@ -981,12 +975,10 @@ new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, ba
                 }
                 request.groupId = params.groupId.unsignedShortValue;
 
-                auto successFn = Callback<ScenesClusterRemoveAllScenesResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1017,8 +1009,9 @@ - (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterStoreSceneResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::StoreScene::Type request;
@@ -1028,12 +1021,10 @@ new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, baseDev
                 request.groupId = params.groupId.unsignedShortValue;
                 request.sceneId = params.sceneId.unsignedCharValue;
 
-                auto successFn = Callback<ScenesClusterStoreSceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1063,13 +1054,14 @@ - (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::RecallScene::Type request;
@@ -1088,12 +1080,10 @@ new MTRCommandSuccessCallbackBridge(
                     }
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1124,8 +1114,10 @@ - (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterGetSceneMembershipResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::GetSceneMembership::Type request;
@@ -1134,12 +1126,10 @@ new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue,
                 }
                 request.groupId = params.groupId.unsignedShortValue;
 
-                auto successFn = Callback<ScenesClusterGetSceneMembershipResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1170,8 +1160,10 @@ - (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterEnhancedAddSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::EnhancedAddScene::Type request;
@@ -1257,12 +1249,10 @@ new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, b
                     }
                 }
 
-                auto successFn = Callback<ScenesClusterEnhancedAddSceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1293,8 +1283,10 @@ - (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterEnhancedViewSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::EnhancedViewScene::Type request;
@@ -1304,12 +1296,10 @@ new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue,
                 request.groupId = params.groupId.unsignedShortValue;
                 request.sceneId = params.sceneId.unsignedCharValue;
 
-                auto successFn = Callback<ScenesClusterEnhancedViewSceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1340,8 +1330,9 @@ - (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ScenesClusterCopySceneResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Scenes::Commands::CopyScene::Type request;
@@ -1354,12 +1345,10 @@ new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, baseDevi
                 request.groupIdTo = params.groupIdTo.unsignedShortValue;
                 request.sceneIdTo = params.sceneIdTo.unsignedCharValue;
 
-                auto successFn = Callback<ScenesClusterCopySceneResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1618,13 +1607,14 @@ - (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OnOff::Commands::Off::Type request;
@@ -1632,12 +1622,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1673,13 +1661,14 @@ - (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OnOff::Commands::On::Type request;
@@ -1687,12 +1676,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1728,13 +1715,14 @@ - (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OnOff::Commands::Toggle::Type request;
@@ -1742,12 +1730,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1777,13 +1763,14 @@ - (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OnOff::Commands::OffWithEffect::Type request;
@@ -1795,12 +1782,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.effectVariant
                     = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1839,13 +1824,14 @@ - (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalScen
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OnOff::Commands::OnWithRecallGlobalScene::Type request;
@@ -1853,12 +1839,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -1888,13 +1872,14 @@ - (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OnOff::Commands::OnWithTimedOff::Type request;
@@ -1906,12 +1891,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.onTime = params.onTime.unsignedShortValue;
                 request.offWaitTime = params.offWaitTime.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2291,13 +2274,14 @@ - (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::MoveToLevel::Type request;
@@ -2314,12 +2298,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2349,13 +2331,14 @@ - (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::Move::Type request;
@@ -2373,12 +2356,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2408,13 +2389,14 @@ - (void)stepWithParams:(MTRLevelControlClusterStepParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::Step::Type request;
@@ -2433,12 +2415,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2468,13 +2448,14 @@ - (void)stopWithParams:(MTRLevelControlClusterStopParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::Stop::Type request;
@@ -2484,12 +2465,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2519,13 +2498,14 @@ - (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnO
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::MoveToLevelWithOnOff::Type request;
@@ -2542,12 +2522,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2577,13 +2555,14 @@ - (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::MoveWithOnOff::Type request;
@@ -2601,12 +2580,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2636,13 +2613,14 @@ - (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::StepWithOnOff::Type request;
@@ -2661,12 +2639,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2696,13 +2672,14 @@ - (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::StopWithOnOff::Type request;
@@ -2712,12 +2689,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -2747,13 +2722,14 @@ - (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFre
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LevelControl::Commands::MoveToClosestFrequency::Type request;
@@ -2762,12 +2738,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.frequency = params.frequency.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -3785,13 +3759,14 @@ - (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::InstantAction::Type request;
@@ -3804,12 +3779,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -3839,13 +3812,14 @@ - (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWit
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::InstantActionWithTransition::Type request;
@@ -3859,12 +3833,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.transitionTime = params.transitionTime.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -3894,13 +3866,14 @@ - (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::StartAction::Type request;
@@ -3913,12 +3886,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -3948,13 +3919,14 @@ - (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurat
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::StartActionWithDuration::Type request;
@@ -3968,12 +3940,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.duration = params.duration.unsignedIntValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4003,13 +3973,14 @@ - (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::StopAction::Type request;
@@ -4022,12 +3993,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4057,13 +4026,14 @@ - (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::PauseAction::Type request;
@@ -4076,12 +4046,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4111,13 +4079,14 @@ - (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurat
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::PauseActionWithDuration::Type request;
@@ -4131,12 +4100,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.duration = params.duration.unsignedIntValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4166,13 +4133,14 @@ - (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::ResumeAction::Type request;
@@ -4185,12 +4153,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4220,13 +4186,14 @@ - (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::EnableAction::Type request;
@@ -4239,12 +4206,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4274,13 +4239,14 @@ - (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDur
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::EnableActionWithDuration::Type request;
@@ -4294,12 +4260,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.duration = params.duration.unsignedIntValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4329,13 +4293,14 @@ - (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::DisableAction::Type request;
@@ -4348,12 +4313,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = params.invokeID.unsignedIntValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4383,13 +4346,14 @@ - (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithD
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Actions::Commands::DisableActionWithDuration::Type request;
@@ -4403,12 +4367,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.duration = params.duration.unsignedIntValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -4657,13 +4619,14 @@ - (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nulla
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Basic::Commands::MfgSpecificPing::Type request;
@@ -4671,12 +4634,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -5008,8 +4969,10 @@ - (void)queryImageWithParams:(MTROtaSoftwareUpdateProviderClusterQueryImageParam
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OtaSoftwareUpdateProvider::Commands::QueryImage::Type request;
@@ -5060,12 +5023,10 @@ new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.cal
                     definedValue_0 = [self asByteSpan:params.metadataForProvider];
                 }
 
-                auto successFn = Callback<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -5096,8 +5057,10 @@ - (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUp
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type request;
@@ -5107,12 +5070,10 @@ new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.ca
                 request.updateToken = [self asByteSpan:params.updateToken];
                 request.newVersion = params.newVersion.unsignedIntValue;
 
-                auto successFn = Callback<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -5142,13 +5103,14 @@ - (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotify
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type request;
@@ -5158,12 +5120,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.updateToken = [self asByteSpan:params.updateToken];
                 request.softwareVersion = params.softwareVersion.unsignedIntValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -5291,13 +5251,14 @@ - (void)announceOtaProviderWithParams:(MTROtaSoftwareUpdateRequestorClusterAnnou
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Type request;
@@ -5315,12 +5276,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.endpoint = params.endpoint.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6188,8 +6147,10 @@ - (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GeneralCommissioningClusterArmFailSafeResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GeneralCommissioning::Commands::ArmFailSafe::Type request;
@@ -6199,12 +6160,10 @@ new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbac
                 request.expiryLengthSeconds = params.expiryLengthSeconds.unsignedShortValue;
                 request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
 
-                auto successFn = Callback<GeneralCommissioningClusterArmFailSafeResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6235,8 +6194,10 @@ - (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulato
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GeneralCommissioning::Commands::SetRegulatoryConfig::Type request;
@@ -6248,13 +6209,10 @@ new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self
                 request.countryCode = [self asCharSpan:params.countryCode];
                 request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
 
-                auto successFn
-                    = Callback<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6298,22 +6256,22 @@ - (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissio
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-                chip::Optional<uint16_t> timedInvokeTimeoutMs;
-                ListFreer listFreer;
-                GeneralCommissioning::Commands::CommissioningComplete::Type request;
-                if (timedInvokeTimeoutMsParam != nil) {
-                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
-                }
+        auto * bridge
+            = new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, completion,
+                ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                    GeneralCommissioningClusterCommissioningCompleteResponseCallbackType successCb, MTRErrorCallback failureCb,
+                    MTRCallbackBridgeBase * bridge) {
+                    chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                    ListFreer listFreer;
+                    GeneralCommissioning::Commands::CommissioningComplete::Type request;
+                    if (timedInvokeTimeoutMsParam != nil) {
+                        timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                    }
 
-                auto successFn
-                    = Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-            });
+                    chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                    return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
+                });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6513,8 +6471,10 @@ - (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NetworkCommissioningClusterScanNetworksResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 NetworkCommissioning::Commands::ScanNetworks::Type request;
@@ -6537,12 +6497,10 @@ new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callba
                     }
                 }
 
-                auto successFn = Callback<NetworkCommissioningClusterScanNetworksResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6573,8 +6531,10 @@ - (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpd
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type request;
@@ -6588,12 +6548,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                     definedValue_0 = params.breadcrumb.unsignedLongLongValue;
                 }
 
-                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6624,8 +6582,10 @@ - (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrU
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type request;
@@ -6638,12 +6598,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                     definedValue_0 = params.breadcrumb.unsignedLongLongValue;
                 }
 
-                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6674,8 +6632,10 @@ - (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkPara
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 NetworkCommissioning::Commands::RemoveNetwork::Type request;
@@ -6688,12 +6648,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                     definedValue_0 = params.breadcrumb.unsignedLongLongValue;
                 }
 
-                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6724,8 +6682,10 @@ - (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkPa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NetworkCommissioningClusterConnectNetworkResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 NetworkCommissioning::Commands::ConnectNetwork::Type request;
@@ -6738,12 +6698,10 @@ new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.call
                     definedValue_0 = params.breadcrumb.unsignedLongLongValue;
                 }
 
-                auto successFn = Callback<NetworkCommissioningClusterConnectNetworkResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -6774,8 +6732,10 @@ - (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkPa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 NetworkCommissioning::Commands::ReorderNetwork::Type request;
@@ -6789,12 +6749,10 @@ new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callb
                     definedValue_0 = params.breadcrumb.unsignedLongLongValue;
                 }
 
-                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -7040,8 +6998,10 @@ - (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsReque
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DiagnosticLogsClusterRetrieveLogsResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DiagnosticLogs::Commands::RetrieveLogsRequest::Type request;
@@ -7053,12 +7013,10 @@ new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueu
                     params.requestedProtocol.unsignedCharValue);
                 request.transferFileDesignator = [self asByteSpan:params.transferFileDesignator];
 
-                auto successFn = Callback<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -7165,13 +7123,14 @@ - (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTrigger
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GeneralDiagnostics::Commands::TestEventTrigger::Type request;
@@ -7181,12 +7140,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.enableKey = [self asByteSpan:params.enableKey];
                 request.eventTrigger = params.eventTrigger.unsignedLongLongValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -7373,13 +7330,14 @@ - (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksP
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 SoftwareDiagnostics::Commands::ResetWatermarks::Type request;
@@ -7387,12 +7345,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -7547,13 +7503,14 @@ - (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsPara
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ThreadNetworkDiagnostics::Commands::ResetCounts::Type request;
@@ -7561,12 +7518,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -8192,13 +8147,14 @@ - (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WiFiNetworkDiagnostics::Commands::ResetCounts::Type request;
@@ -8206,12 +8162,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -8436,13 +8390,14 @@ - (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsPa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 EthernetNetworkDiagnostics::Commands::ResetCounts::Type request;
@@ -8450,12 +8405,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -8934,13 +8887,14 @@ - (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterO
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AdministratorCommissioning::Commands::OpenCommissioningWindow::Type request;
@@ -8956,12 +8910,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.iterations = params.iterations.unsignedIntValue;
                 request.salt = [self asByteSpan:params.salt];
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -8991,13 +8943,14 @@ - (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type request;
@@ -9009,12 +8962,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.commissioningTimeout = params.commissioningTimeout.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9053,13 +9004,14 @@ - (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevok
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AdministratorCommissioning::Commands::RevokeCommissioning::Type request;
@@ -9070,12 +9022,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(10000);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9234,8 +9184,10 @@ - (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestatio
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterAttestationResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::AttestationRequest::Type request;
@@ -9244,12 +9196,10 @@ new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callb
                 }
                 request.attestationNonce = [self asByteSpan:params.attestationNonce];
 
-                auto successFn = Callback<OperationalCredentialsClusterAttestationResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9280,8 +9230,10 @@ - (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCerti
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterCertificateChainResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::CertificateChainRequest::Type request;
@@ -9290,13 +9242,10 @@ new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.
                 }
                 request.certificateType = params.certificateType.unsignedCharValue;
 
-                auto successFn
-                    = Callback<OperationalCredentialsClusterCertificateChainResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9327,8 +9276,10 @@ - (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterCSRResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::CSRRequest::Type request;
@@ -9341,12 +9292,10 @@ new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue
                     definedValue_0 = params.isForUpdateNOC.boolValue;
                 }
 
-                auto successFn = Callback<OperationalCredentialsClusterCSRResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9377,8 +9326,10 @@ - (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::AddNOC::Type request;
@@ -9395,12 +9346,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
                 request.adminVendorId = static_cast<std::remove_reference_t<decltype(request.adminVendorId)>>(
                     params.adminVendorId.unsignedShortValue);
 
-                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9431,8 +9380,10 @@ - (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::UpdateNOC::Type request;
@@ -9445,12 +9396,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
                     definedValue_0 = [self asByteSpan:params.icacValue];
                 }
 
-                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9481,8 +9430,10 @@ - (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabri
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::UpdateFabricLabel::Type request;
@@ -9491,12 +9442,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
                 }
                 request.label = [self asCharSpan:params.label];
 
-                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9527,8 +9476,10 @@ - (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricPara
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::RemoveFabric::Type request;
@@ -9537,12 +9488,10 @@ new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue
                 }
                 request.fabricIndex = params.fabricIndex.unsignedCharValue;
 
-                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9572,13 +9521,14 @@ - (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAdd
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 OperationalCredentials::Commands::AddTrustedRootCertificate::Type request;
@@ -9587,12 +9537,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.rootCertificate = [self asByteSpan:params.rootCertificate];
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9823,13 +9771,14 @@ - (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GroupKeyManagement::Commands::KeySetWrite::Type request;
@@ -9877,12 +9826,10 @@ new MTRCommandSuccessCallbackBridge(
                     nonNullValue_1 = params.groupKeySet.epochStartTime2.unsignedLongLongValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9913,8 +9860,10 @@ - (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GroupKeyManagementClusterKeySetReadResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GroupKeyManagement::Commands::KeySetRead::Type request;
@@ -9923,12 +9872,10 @@ new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQu
                 }
                 request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
 
-                auto successFn = Callback<GroupKeyManagementClusterKeySetReadResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -9958,13 +9905,14 @@ - (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GroupKeyManagement::Commands::KeySetRemove::Type request;
@@ -9973,12 +9921,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10009,8 +9955,10 @@ - (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAl
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 GroupKeyManagement::Commands::KeySetReadAllIndices::Type request;
@@ -10040,13 +9988,10 @@ new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.
                     }
                 }
 
-                auto successFn
-                    = Callback<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10476,13 +10421,14 @@ - (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ModeSelect::Commands::ChangeToMode::Type request;
@@ -10491,12 +10437,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.newMode = params.newMode.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10688,13 +10632,14 @@ - (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::LockDoor::Type request;
@@ -10711,12 +10656,10 @@ new MTRCommandSuccessCallbackBridge(
                     }
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10746,13 +10689,14 @@ - (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::UnlockDoor::Type request;
@@ -10769,12 +10713,10 @@ new MTRCommandSuccessCallbackBridge(
                     }
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10804,13 +10746,14 @@ - (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::UnlockWithTimeout::Type request;
@@ -10826,12 +10769,10 @@ new MTRCommandSuccessCallbackBridge(
                     definedValue_0 = [self asByteSpan:params.pinCode];
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10861,13 +10802,14 @@ - (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::SetWeekDaySchedule::Type request;
@@ -10883,12 +10825,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.endHour = params.endHour.unsignedCharValue;
                 request.endMinute = params.endMinute.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10919,8 +10859,10 @@ - (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DoorLockClusterGetWeekDayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::GetWeekDaySchedule::Type request;
@@ -10930,12 +10872,10 @@ new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueu
                 request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
                 request.userIndex = params.userIndex.unsignedShortValue;
 
-                auto successFn = Callback<DoorLockClusterGetWeekDayScheduleResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -10965,13 +10905,14 @@ - (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDaySchedulePa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::ClearWeekDaySchedule::Type request;
@@ -10981,12 +10922,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
                 request.userIndex = params.userIndex.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11016,13 +10955,14 @@ - (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::SetYearDaySchedule::Type request;
@@ -11034,12 +10974,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.localStartTime = params.localStartTime.unsignedIntValue;
                 request.localEndTime = params.localEndTime.unsignedIntValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11070,8 +11008,10 @@ - (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DoorLockClusterGetYearDayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::GetYearDaySchedule::Type request;
@@ -11081,12 +11021,10 @@ new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueu
                 request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
                 request.userIndex = params.userIndex.unsignedShortValue;
 
-                auto successFn = Callback<DoorLockClusterGetYearDayScheduleResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11116,13 +11054,14 @@ - (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDaySchedulePa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::ClearYearDaySchedule::Type request;
@@ -11132,12 +11071,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
                 request.userIndex = params.userIndex.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11167,13 +11104,14 @@ - (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::SetHolidaySchedule::Type request;
@@ -11186,12 +11124,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.operatingMode
                     = static_cast<std::remove_reference_t<decltype(request.operatingMode)>>(params.operatingMode.unsignedCharValue);
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11222,8 +11158,10 @@ - (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DoorLockClusterGetHolidayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::GetHolidaySchedule::Type request;
@@ -11232,12 +11170,10 @@ new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueu
                 }
                 request.holidayIndex = params.holidayIndex.unsignedCharValue;
 
-                auto successFn = Callback<DoorLockClusterGetHolidayScheduleResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11267,13 +11203,14 @@ - (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidaySchedulePa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::ClearHolidaySchedule::Type request;
@@ -11282,12 +11219,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.holidayIndex = params.holidayIndex.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11317,13 +11252,14 @@ - (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::SetUser::Type request;
@@ -11370,12 +11306,10 @@ new MTRCommandSuccessCallbackBridge(
                         = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.credentialRule.unsignedCharValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11405,8 +11339,9 @@ - (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DoorLockClusterGetUserResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::GetUser::Type request;
@@ -11415,12 +11350,10 @@ new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, baseDevi
                 }
                 request.userIndex = params.userIndex.unsignedShortValue;
 
-                auto successFn = Callback<DoorLockClusterGetUserResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11450,13 +11383,14 @@ - (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::ClearUser::Type request;
@@ -11468,12 +11402,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.userIndex = params.userIndex.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11504,8 +11436,10 @@ - (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DoorLockClusterSetCredentialResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::SetCredential::Type request;
@@ -11543,12 +11477,10 @@ new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, ba
                         = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userType.unsignedCharValue);
                 }
 
-                auto successFn = Callback<DoorLockClusterSetCredentialResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11579,8 +11511,10 @@ - (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusPara
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                DoorLockClusterGetCredentialStatusResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::GetCredentialStatus::Type request;
@@ -11592,12 +11526,10 @@ new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQue
                         params.credential.credentialType.unsignedCharValue);
                 request.credential.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
 
-                auto successFn = Callback<DoorLockClusterGetCredentialStatusResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -11627,13 +11559,14 @@ - (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)par
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 DoorLock::Commands::ClearCredential::Type request;
@@ -11652,12 +11585,10 @@ new MTRCommandSuccessCallbackBridge(
                     nonNullValue_0.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12589,13 +12520,14 @@ - (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::UpOrOpen::Type request;
@@ -12603,12 +12535,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12647,13 +12577,14 @@ - (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Null
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::DownOrClose::Type request;
@@ -12661,12 +12592,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12705,13 +12634,14 @@ - (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullab
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::StopMotion::Type request;
@@ -12719,12 +12649,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12754,13 +12682,14 @@ - (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::GoToLiftValue::Type request;
@@ -12769,12 +12698,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.liftValue = params.liftValue.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12804,13 +12731,14 @@ - (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentage
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::GoToLiftPercentage::Type request;
@@ -12819,12 +12747,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.liftPercent100thsValue = params.liftPercent100thsValue.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12854,13 +12780,14 @@ - (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::GoToTiltValue::Type request;
@@ -12869,12 +12796,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.tiltValue = params.tiltValue.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -12904,13 +12829,14 @@ - (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentage
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 WindowCovering::Commands::GoToTiltPercentage::Type request;
@@ -12919,12 +12845,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.tiltPercent100thsValue = params.tiltPercent100thsValue.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -13303,13 +13227,14 @@ - (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierCont
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 BarrierControl::Commands::BarrierControlGoToPercent::Type request;
@@ -13318,12 +13243,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.percentOpen = params.percentOpen.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -13362,13 +13285,14 @@ - (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStop
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 BarrierControl::Commands::BarrierControlStop::Type request;
@@ -13376,12 +13300,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -14031,13 +13953,14 @@ - (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerPara
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Thermostat::Commands::SetpointRaiseLower::Type request;
@@ -14047,12 +13970,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.mode = static_cast<std::remove_reference_t<decltype(request.mode)>>(params.mode.unsignedCharValue);
                 request.amount = params.amount.charValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -14082,13 +14003,14 @@ - (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Thermostat::Commands::SetWeeklySchedule::Type request;
@@ -14135,12 +14057,10 @@ new MTRCommandSuccessCallbackBridge(
                     }
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -14171,8 +14091,10 @@ - (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ThermostatClusterGetWeeklyScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Thermostat::Commands::GetWeeklySchedule::Type request;
@@ -14184,12 +14106,10 @@ new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQue
                 request.modeToReturn
                     = static_cast<std::remove_reference_t<decltype(request.modeToReturn)>>(params.modeToReturn.unsignedCharValue);
 
-                auto successFn = Callback<ThermostatClusterGetWeeklyScheduleResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -14228,13 +14148,14 @@ - (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklySchedulePa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Thermostat::Commands::ClearWeeklySchedule::Type request;
@@ -14242,12 +14163,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -15739,13 +15658,14 @@ - (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveToHue::Type request;
@@ -15759,12 +15679,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -15794,13 +15712,14 @@ - (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveHue::Type request;
@@ -15813,12 +15732,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -15848,13 +15765,14 @@ - (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::StepHue::Type request;
@@ -15868,12 +15786,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -15903,13 +15819,14 @@ - (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveToSaturation::Type request;
@@ -15921,12 +15838,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -15956,13 +15871,14 @@ - (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveSaturation::Type request;
@@ -15975,12 +15891,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16010,13 +15924,14 @@ - (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)p
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::StepSaturation::Type request;
@@ -16030,12 +15945,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16065,13 +15978,14 @@ - (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSatu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveToHueAndSaturation::Type request;
@@ -16084,12 +15998,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16119,13 +16031,14 @@ - (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveToColor::Type request;
@@ -16138,12 +16051,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16173,13 +16084,14 @@ - (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveColor::Type request;
@@ -16191,12 +16103,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16226,13 +16136,14 @@ - (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::StepColor::Type request;
@@ -16245,12 +16156,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16280,13 +16189,14 @@ - (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTempe
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveToColorTemperature::Type request;
@@ -16298,12 +16208,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16333,13 +16241,14 @@ - (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHuePara
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::EnhancedMoveToHue::Type request;
@@ -16353,12 +16262,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16388,13 +16295,14 @@ - (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::EnhancedMoveHue::Type request;
@@ -16407,12 +16315,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16442,13 +16348,14 @@ - (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::EnhancedStepHue::Type request;
@@ -16462,12 +16369,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16497,13 +16402,14 @@ - (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhanced
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type request;
@@ -16516,12 +16422,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16551,13 +16455,14 @@ - (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)param
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::ColorLoopSet::Type request;
@@ -16574,12 +16479,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16609,13 +16512,14 @@ - (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)param
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::StopMoveStep::Type request;
@@ -16625,12 +16529,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16660,13 +16562,14 @@ - (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::MoveColorTemperature::Type request;
@@ -16681,12 +16584,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -16716,13 +16617,14 @@ - (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ColorControl::Commands::StepColorTemperature::Type request;
@@ -16738,12 +16640,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.optionsMask = params.optionsMask.unsignedCharValue;
                 request.optionsOverride = params.optionsOverride.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19034,8 +18934,10 @@ - (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ChannelClusterChangeChannelResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Channel::Commands::ChangeChannel::Type request;
@@ -19044,12 +18946,10 @@ new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, bas
                 }
                 request.match = [self asCharSpan:params.match];
 
-                auto successFn = Callback<ChannelClusterChangeChannelResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19079,13 +18979,14 @@ - (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberP
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Channel::Commands::ChangeChannelByNumber::Type request;
@@ -19095,12 +18996,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.majorNumber = params.majorNumber.unsignedShortValue;
                 request.minorNumber = params.minorNumber.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19130,13 +19029,14 @@ - (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 Channel::Commands::SkipChannel::Type request;
@@ -19145,12 +19045,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.count = params.count.unsignedShortValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19302,8 +19200,10 @@ - (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TargetNavigatorClusterNavigateTargetResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TargetNavigator::Commands::NavigateTarget::Type request;
@@ -19316,12 +19216,10 @@ new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQ
                     definedValue_0 = [self asCharSpan:params.data];
                 }
 
-                auto successFn = Callback<TargetNavigatorClusterNavigateTargetResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19452,8 +19350,10 @@ - (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::Play::Type request;
@@ -19461,12 +19361,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19504,8 +19402,10 @@ - (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::Pause::Type request;
@@ -19513,12 +19413,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19559,8 +19457,10 @@ - (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nul
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::StopPlayback::Type request;
@@ -19568,12 +19468,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19614,8 +19512,10 @@ - (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::StartOver::Type request;
@@ -19623,12 +19523,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19666,8 +19564,10 @@ - (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)pa
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::Previous::Type request;
@@ -19675,12 +19575,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19718,8 +19616,10 @@ - (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::Next::Type request;
@@ -19727,12 +19627,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19770,8 +19668,10 @@ - (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::Rewind::Type request;
@@ -19779,12 +19679,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19825,8 +19723,10 @@ - (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nulla
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::FastForward::Type request;
@@ -19834,12 +19734,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19870,8 +19768,10 @@ - (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::SkipForward::Type request;
@@ -19880,12 +19780,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                 }
                 request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19916,8 +19814,10 @@ - (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)para
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::SkipBackward::Type request;
@@ -19926,12 +19826,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                 }
                 request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -19962,8 +19860,10 @@ - (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaPlayback::Commands::Seek::Type request;
@@ -19972,12 +19872,10 @@ new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, ba
                 }
                 request.position = params.position.unsignedLongLongValue;
 
-                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20306,13 +20204,14 @@ - (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaInput::Commands::SelectInput::Type request;
@@ -20321,12 +20220,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.index = params.index.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20365,13 +20262,14 @@ - (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaInput::Commands::ShowInputStatus::Type request;
@@ -20379,12 +20277,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20423,13 +20319,14 @@ - (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaInput::Commands::HideInputStatus::Type request;
@@ -20437,12 +20334,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20472,13 +20367,14 @@ - (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 MediaInput::Commands::RenameInput::Type request;
@@ -20488,12 +20384,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.index = params.index.unsignedCharValue;
                 request.name = [self asCharSpan:params.name];
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20667,13 +20561,14 @@ - (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 LowPower::Commands::Sleep::Type request;
@@ -20681,12 +20576,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20799,8 +20692,10 @@ - (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                KeypadInputClusterSendKeyResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 KeypadInput::Commands::SendKey::Type request;
@@ -20809,12 +20704,10 @@ new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, baseD
                 }
                 request.keyCode = static_cast<std::remove_reference_t<decltype(request.keyCode)>>(params.keyCode.unsignedCharValue);
 
-                auto successFn = Callback<KeypadInputClusterSendKeyResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -20922,8 +20815,10 @@ - (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ContentLauncherClusterLaunchResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ContentLauncher::Commands::LaunchContent::Type request;
@@ -20989,12 +20884,10 @@ new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, ba
                     definedValue_0 = [self asCharSpan:params.data];
                 }
 
-                auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21025,8 +20918,10 @@ - (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ContentLauncherClusterLaunchResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ContentLauncher::Commands::LaunchURL::Type request;
@@ -21133,12 +21028,10 @@ new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, ba
                     }
                 }
 
-                auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21293,13 +21186,14 @@ - (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AudioOutput::Commands::SelectOutput::Type request;
@@ -21308,12 +21202,10 @@ new MTRCommandSuccessCallbackBridge(
                 }
                 request.index = params.index.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21343,13 +21235,14 @@ - (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AudioOutput::Commands::RenameOutput::Type request;
@@ -21359,12 +21252,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.index = params.index.unsignedCharValue;
                 request.name = [self asCharSpan:params.name];
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21497,8 +21388,10 @@ - (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams *)para
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ApplicationLauncher::Commands::LaunchApp::Type request;
@@ -21512,12 +21405,10 @@ new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQue
                     definedValue_0 = [self asByteSpan:params.data];
                 }
 
-                auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21548,8 +21439,10 @@ - (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ApplicationLauncher::Commands::StopApp::Type request;
@@ -21559,12 +21452,10 @@ new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQue
                 request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
                 request.application.applicationId = [self asCharSpan:params.application.applicationId];
 
-                auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21595,8 +21486,10 @@ - (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ApplicationLauncher::Commands::HideApp::Type request;
@@ -21606,12 +21499,10 @@ new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQue
                 request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
                 request.application.applicationId = [self asCharSpan:params.application.applicationId];
 
-                auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21906,8 +21797,10 @@ - (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                AccountLoginClusterGetSetupPINResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AccountLogin::Commands::GetSetupPIN::Type request;
@@ -21919,12 +21812,10 @@ new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue,
                 }
                 request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
 
-                auto successFn = Callback<AccountLoginClusterGetSetupPINResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -21954,13 +21845,14 @@ - (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AccountLogin::Commands::Login::Type request;
@@ -21973,12 +21865,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
                 request.setupPIN = [self asCharSpan:params.setupPIN];
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -22014,13 +21904,14 @@ - (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 AccountLogin::Commands::Logout::Type request;
@@ -22031,12 +21922,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(10000);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -22178,13 +22067,14 @@ - (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfi
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ElectricalMeasurement::Commands::GetProfileInfoCommand::Type request;
@@ -22192,12 +22082,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -22227,13 +22115,14 @@ - (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterG
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Type request;
@@ -22244,12 +22133,10 @@ new MTRCommandSuccessCallbackBridge(
                 request.startTime = params.startTime.unsignedIntValue;
                 request.numberOfIntervals = params.numberOfIntervals.unsignedCharValue;
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23567,13 +23454,14 @@ - (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::Test::Type request;
@@ -23581,12 +23469,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23625,13 +23511,14 @@ - (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _N
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestNotHandled::Type request;
@@ -23639,12 +23526,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23685,8 +23570,10 @@ - (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nulla
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestSpecificResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestSpecific::Type request;
@@ -23694,12 +23581,10 @@ new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue,
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<TestClusterClusterTestSpecificResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23738,13 +23623,14 @@ - (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandPar
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestUnknownCommand::Type request;
@@ -23752,12 +23638,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23788,8 +23672,10 @@ - (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestAddArgumentsResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestAddArguments::Type request;
@@ -23799,12 +23685,10 @@ new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQue
                 request.arg1 = params.arg1.unsignedCharValue;
                 request.arg2 = params.arg2.unsignedCharValue;
 
-                auto successFn = Callback<TestClusterClusterTestAddArgumentsResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23835,8 +23719,10 @@ - (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestSimpleArgumentResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestSimpleArgumentRequest::Type request;
@@ -23845,12 +23731,10 @@ new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQ
                 }
                 request.arg1 = params.arg1.boolValue;
 
-                auto successFn = Callback<TestClusterClusterTestSimpleArgumentResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -23882,8 +23766,10 @@ - (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStruc
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestStructArrayArgumentResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestStructArrayArgumentRequest::Type request;
@@ -24103,12 +23989,10 @@ new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.call
                 request.arg5 = static_cast<std::remove_reference_t<decltype(request.arg5)>>(params.arg5.unsignedCharValue);
                 request.arg6 = params.arg6.boolValue;
 
-                auto successFn = Callback<TestClusterClusterTestStructArrayArgumentResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24139,8 +24023,10 @@ - (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterBooleanResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestStructArgumentRequest::Type request;
@@ -24156,12 +24042,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseD
                 request.arg1.g = params.arg1.g.floatValue;
                 request.arg1.h = params.arg1.h.doubleValue;
 
-                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24192,8 +24076,10 @@ - (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNest
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterBooleanResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestNestedStructArgumentRequest::Type request;
@@ -24213,12 +24099,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseD
                 request.arg1.c.g = params.arg1.c.g.floatValue;
                 request.arg1.c.h = params.arg1.c.h.doubleValue;
 
-                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24249,8 +24133,10 @@ - (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListSt
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterBooleanResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestListStructArgumentRequest::Type request;
@@ -24289,12 +24175,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseD
                     }
                 }
 
-                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24325,8 +24209,10 @@ - (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterBooleanResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestListInt8UArgumentRequest::Type request;
@@ -24356,12 +24242,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseD
                     }
                 }
 
-                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24392,8 +24276,10 @@ - (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTest
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterBooleanResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestNestedStructListArgumentRequest::Type request;
@@ -24510,12 +24396,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseD
                     }
                 }
 
-                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24547,8 +24431,10 @@ - (void)testListNestedStructListArgumentRequestWithParams:
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterBooleanResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestListNestedStructListArgumentRequest::Type request;
@@ -24690,12 +24576,10 @@ new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseD
                     }
                 }
 
-                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24726,8 +24610,10 @@ - (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestListInt8UReverseResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestListInt8UReverseRequest::Type request;
@@ -24757,12 +24643,10 @@ new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbac
                     }
                 }
 
-                auto successFn = Callback<TestClusterClusterTestListInt8UReverseResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24793,8 +24677,10 @@ - (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestEnumsResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestEnumsRequest::Type request;
@@ -24804,12 +24690,10 @@ new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, bas
                 request.arg1 = static_cast<std::remove_reference_t<decltype(request.arg1)>>(params.arg1.unsignedShortValue);
                 request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
 
-                auto successFn = Callback<TestClusterClusterTestEnumsResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24840,8 +24724,10 @@ - (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullable
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestNullableOptionalResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestNullableOptionalRequest::Type request;
@@ -24860,12 +24746,10 @@ new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbac
                     }
                 }
 
-                auto successFn = Callback<TestClusterClusterTestNullableOptionalResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -24898,8 +24782,10 @@ - (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestC
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestComplexNullableOptionalResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestComplexNullableOptionalRequest::Type request;
@@ -25077,13 +24963,10 @@ new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.
                     }
                 }
 
-                auto successFn
-                    = Callback<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -25114,8 +24997,10 @@ - (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEcho
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterSimpleStructResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::SimpleStructEchoRequest::Type request;
@@ -25131,12 +25016,10 @@ new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue,
                 request.arg1.g = params.arg1.g.floatValue;
                 request.arg1.h = params.arg1.h.doubleValue;
 
-                auto successFn = Callback<TestClusterClusterSimpleStructResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -25175,13 +25058,14 @@ - (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestPar
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TimedInvokeRequest::Type request;
@@ -25192,12 +25076,10 @@ new MTRCommandSuccessCallbackBridge(
                     timedInvokeTimeoutMs.SetValue(10000);
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -25227,13 +25109,14 @@ - (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSi
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRCommandSuccessCallbackBridge(
-            self.callbackQueue, baseDevice,
+        auto * bridge = new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue,
             ^(id _Nullable value, NSError * _Nullable error) {
                 completion(error);
                 [workItem endWork];
             },
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
+                MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type request;
@@ -25247,12 +25130,10 @@ new MTRCommandSuccessCallbackBridge(
                     }
                 }
 
-                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -25283,8 +25164,10 @@ - (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEve
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestEmitTestEventResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestEmitTestEventRequest::Type request;
@@ -25295,12 +25178,10 @@ new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQu
                 request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
                 request.arg3 = params.arg3.boolValue;
 
-                auto successFn = Callback<TestClusterClusterTestEmitTestEventResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
@@ -25334,8 +25215,10 @@ new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQu
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
         MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
                                                                 controller:self.device.deviceController];
-        new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, baseDevice, completion,
-            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+        auto * bridge = new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, completion,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
+                TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType successCb, MTRErrorCallback failureCb,
+                MTRCallbackBridgeBase * bridge) {
                 chip::Optional<uint16_t> timedInvokeTimeoutMs;
                 ListFreer listFreer;
                 TestCluster::Commands::TestEmitTestFabricScopedEventRequest::Type request;
@@ -25344,13 +25227,10 @@ new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(sel
                 }
                 request.arg1 = params.arg1.unsignedCharValue;
 
-                auto successFn
-                    = Callback<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>::FromCancelable(success);
-                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
                 chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-                return cppCluster.InvokeCommand(
-                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+                return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
             });
+        std::move(*bridge).DispatchAction(baseDevice);
     };
     workItem.readyHandler = readyHandler;
     [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];